From 25b23998ad2feadd7373b341bbbb8d87a3ec9d8a Mon Sep 17 00:00:00 2001
From: Zanie <contact@zanie.dev>
Date: Mon, 10 Jul 2023 13:14:46 -0500
Subject: [PATCH 1/6] Update Python ASDL for Python 3.12

From https://github.com/python/cpython/commit/46c1097868745eeb47abbc8af8c34e8fcb80ff1d
---
 ast/Python.asdl | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/ast/Python.asdl b/ast/Python.asdl
index e9423a7c..0d154867 100644
--- a/ast/Python.asdl
+++ b/ast/Python.asdl
@@ -10,20 +10,22 @@ module Python
 
     stmt = FunctionDef(identifier name, arguments args,
                        stmt* body, expr* decorator_list, expr? returns,
-                       string? type_comment)
+                       string? type_comment, type_param* type_params)
           | AsyncFunctionDef(identifier name, arguments args,
                              stmt* body, expr* decorator_list, expr? returns,
-                             string? type_comment)
+                             string? type_comment, type_param* type_params)
 
           | ClassDef(identifier name,
              expr* bases,
              keyword* keywords,
              stmt* body,
-             expr* decorator_list)
+             expr* decorator_list,
+             type_param* type_params)
           | Return(expr? value)
 
           | Delete(expr* targets)
           | Assign(expr* targets, expr value, string? type_comment)
+          | TypeAlias(expr name, type_param* type_params, expr value)
           | AugAssign(expr target, operator op, expr value)
           -- 'simple' indicates that we annotate simple name without parens
           | AnnAssign(expr target, expr annotation, expr? value, int simple)
@@ -142,4 +144,9 @@ module Python
              attributes (int lineno, int col_offset, int end_lineno, int end_col_offset)
 
     type_ignore = TypeIgnore(int lineno, string tag)
+
+    type_param = TypeVar(identifier name, expr? bound)
+               | ParamSpec(identifier name)
+               | TypeVarTuple(identifier name)
+               attributes (int lineno, int col_offset, int end_lineno, int end_col_offset)
 }

From df2b5dfed015e04bb2bc514ea22d2c262bb8c282 Mon Sep 17 00:00:00 2001
From: Zanie <contact@zanie.dev>
Date: Mon, 10 Jul 2023 13:45:36 -0500
Subject: [PATCH 2/6] Regenerate code with latest ASDL

---
 ast-pyo3/src/gen/to_py_ast.rs       |   259 +
 ast-pyo3/src/gen/wrapper_located.rs |   217 +
 ast-pyo3/src/gen/wrapper_ranged.rs  |   217 +
 ast/src/gen/fold.rs                 |   153 +
 ast/src/gen/generic.rs              |   131 +-
 ast/src/gen/located.rs              |    80 +
 ast/src/gen/ranged.rs               |    31 +
 ast/src/gen/visitor.rs              |    52 +
 parser/src/gen/parse.rs             |    23 +
 parser/src/python.rs                | 27989 ++++++++------------------
 10 files changed, 9538 insertions(+), 19614 deletions(-)

diff --git a/ast-pyo3/src/gen/to_py_ast.rs b/ast-pyo3/src/gen/to_py_ast.rs
index c3288f28..8c8ea3ec 100644
--- a/ast-pyo3/src/gen/to_py_ast.rs
+++ b/ast-pyo3/src/gen/to_py_ast.rs
@@ -96,6 +96,14 @@ impl<R> PyNode for ast::StmtAssign<R> {
     }
 }
 
+impl<R> PyNode for ast::StmtTypeAlias<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
 impl<R> PyNode for ast::StmtAugAssign<R> {
     #[inline]
     fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
@@ -944,6 +952,38 @@ impl<R> PyNode for ast::TypeIgnoreTypeIgnore<R> {
     }
 }
 
+impl<R> PyNode for ast::TypeParam<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::TypeParamTypeVar<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::TypeParamParamSpec<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
+impl<R> PyNode for ast::TypeParamTypeVarTuple<R> {
+    #[inline]
+    fn py_type_cache() -> &'static OnceCell<(Py<PyAny>, Py<PyAny>)> {
+        static PY_TYPE: OnceCell<(Py<PyAny>, Py<PyAny>)> = OnceCell::new();
+        &PY_TYPE
+    }
+}
+
 impl ToPyAst for ast::ExprContext {
     #[inline]
     fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
@@ -1112,6 +1152,7 @@ impl ToPyAst for ast::Stmt<TextRange> {
             ast::Stmt::Return(cons) => cons.to_py_ast(py)?,
             ast::Stmt::Delete(cons) => cons.to_py_ast(py)?,
             ast::Stmt::Assign(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::TypeAlias(cons) => cons.to_py_ast(py)?,
             ast::Stmt::AugAssign(cons) => cons.to_py_ast(py)?,
             ast::Stmt::AnnAssign(cons) => cons.to_py_ast(py)?,
             ast::Stmt::For(cons) => cons.to_py_ast(py)?,
@@ -1150,6 +1191,7 @@ impl ToPyAst for ast::StmtFunctionDef<TextRange> {
             decorator_list,
             returns,
             type_comment,
+            type_params,
             range: _range,
         } = self;
 
@@ -1160,6 +1202,7 @@ impl ToPyAst for ast::StmtFunctionDef<TextRange> {
             decorator_list.to_py_ast(py)?,
             returns.to_py_ast(py)?,
             type_comment.to_py_ast(py)?,
+            type_params.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
@@ -1178,6 +1221,7 @@ impl ToPyAst for ast::StmtAsyncFunctionDef<TextRange> {
             decorator_list,
             returns,
             type_comment,
+            type_params,
             range: _range,
         } = self;
 
@@ -1188,6 +1232,7 @@ impl ToPyAst for ast::StmtAsyncFunctionDef<TextRange> {
             decorator_list.to_py_ast(py)?,
             returns.to_py_ast(py)?,
             type_comment.to_py_ast(py)?,
+            type_params.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
@@ -1205,6 +1250,7 @@ impl ToPyAst for ast::StmtClassDef<TextRange> {
             keywords,
             body,
             decorator_list,
+            type_params,
             range: _range,
         } = self;
 
@@ -1214,6 +1260,7 @@ impl ToPyAst for ast::StmtClassDef<TextRange> {
             keywords.to_py_ast(py)?,
             body.to_py_ast(py)?,
             decorator_list.to_py_ast(py)?,
+            type_params.to_py_ast(py)?,
         ))?;
 
         Ok(instance)
@@ -1274,6 +1321,28 @@ impl ToPyAst for ast::StmtAssign<TextRange> {
     }
 }
 
+impl ToPyAst for ast::StmtTypeAlias<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            name,
+            type_params,
+            value,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            name.to_py_ast(py)?,
+            type_params.to_py_ast(py)?,
+            value.to_py_ast(py)?,
+        ))?;
+
+        Ok(instance)
+    }
+}
+
 impl ToPyAst for ast::StmtAugAssign<TextRange> {
     #[inline]
     fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
@@ -2605,6 +2674,68 @@ impl ToPyAst for ast::TypeIgnoreTypeIgnore<TextRange> {
     }
 }
 
+impl ToPyAst for ast::TypeParam<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let instance = match &self {
+            ast::TypeParam::TypeVar(cons) => cons.to_py_ast(py)?,
+            ast::TypeParam::ParamSpec(cons) => cons.to_py_ast(py)?,
+            ast::TypeParam::TypeVarTuple(cons) => cons.to_py_ast(py)?,
+        };
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::TypeParamTypeVar<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            name,
+            bound,
+            range: _range,
+        } = self;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((name.to_py_ast(py)?, bound.to_py_ast(py)?))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::TypeParamParamSpec<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            name,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((name.to_py_ast(py)?,))?;
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::TypeParamTypeVarTuple<TextRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            name,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((name.to_py_ast(py)?,))?;
+
+        Ok(instance)
+    }
+}
+
 impl ToPyAst for ast::Mod<SourceRange> {
     #[inline]
     fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
@@ -2696,6 +2827,7 @@ impl ToPyAst for ast::Stmt<SourceRange> {
             ast::Stmt::Return(cons) => cons.to_py_ast(py)?,
             ast::Stmt::Delete(cons) => cons.to_py_ast(py)?,
             ast::Stmt::Assign(cons) => cons.to_py_ast(py)?,
+            ast::Stmt::TypeAlias(cons) => cons.to_py_ast(py)?,
             ast::Stmt::AugAssign(cons) => cons.to_py_ast(py)?,
             ast::Stmt::AnnAssign(cons) => cons.to_py_ast(py)?,
             ast::Stmt::For(cons) => cons.to_py_ast(py)?,
@@ -2734,6 +2866,7 @@ impl ToPyAst for ast::StmtFunctionDef<SourceRange> {
             decorator_list,
             returns,
             type_comment,
+            type_params,
             range: _range,
         } = self;
 
@@ -2744,6 +2877,7 @@ impl ToPyAst for ast::StmtFunctionDef<SourceRange> {
             decorator_list.to_py_ast(py)?,
             returns.to_py_ast(py)?,
             type_comment.to_py_ast(py)?,
+            type_params.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -2770,6 +2904,7 @@ impl ToPyAst for ast::StmtAsyncFunctionDef<SourceRange> {
             decorator_list,
             returns,
             type_comment,
+            type_params,
             range: _range,
         } = self;
 
@@ -2780,6 +2915,7 @@ impl ToPyAst for ast::StmtAsyncFunctionDef<SourceRange> {
             decorator_list.to_py_ast(py)?,
             returns.to_py_ast(py)?,
             type_comment.to_py_ast(py)?,
+            type_params.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -2805,6 +2941,7 @@ impl ToPyAst for ast::StmtClassDef<SourceRange> {
             keywords,
             body,
             decorator_list,
+            type_params,
             range: _range,
         } = self;
 
@@ -2814,6 +2951,7 @@ impl ToPyAst for ast::StmtClassDef<SourceRange> {
             keywords.to_py_ast(py)?,
             body.to_py_ast(py)?,
             decorator_list.to_py_ast(py)?,
+            type_params.to_py_ast(py)?,
         ))?;
 
         let cache = ast_cache();
@@ -2906,6 +3044,36 @@ impl ToPyAst for ast::StmtAssign<SourceRange> {
     }
 }
 
+impl ToPyAst for ast::StmtTypeAlias<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            name,
+            type_params,
+            value,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((
+            name.to_py_ast(py)?,
+            type_params.to_py_ast(py)?,
+            value.to_py_ast(py)?,
+        ))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
 impl ToPyAst for ast::StmtAugAssign<SourceRange> {
     #[inline]
     fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
@@ -4717,6 +4885,92 @@ impl ToPyAst for ast::TypeIgnoreTypeIgnore<SourceRange> {
     }
 }
 
+impl ToPyAst for ast::TypeParam<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let instance = match &self {
+            ast::TypeParam::TypeVar(cons) => cons.to_py_ast(py)?,
+            ast::TypeParam::ParamSpec(cons) => cons.to_py_ast(py)?,
+            ast::TypeParam::TypeVarTuple(cons) => cons.to_py_ast(py)?,
+        };
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::TypeParamTypeVar<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            name,
+            bound,
+            range: _range,
+        } = self;
+
+        let instance =
+            Py::<PyAny>::as_ref(&cache.0, py).call1((name.to_py_ast(py)?, bound.to_py_ast(py)?))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::TypeParamParamSpec<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            name,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((name.to_py_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
+impl ToPyAst for ast::TypeParamTypeVarTuple<SourceRange> {
+    #[inline]
+    fn to_py_ast<'py>(&self, py: Python<'py>) -> PyResult<&'py PyAny> {
+        let cache = Self::py_type_cache().get().unwrap();
+
+        let Self {
+            name,
+            range: _range,
+        } = self;
+
+        let instance = Py::<PyAny>::as_ref(&cache.0, py).call1((name.to_py_ast(py)?,))?;
+
+        let cache = ast_cache();
+        instance.setattr(cache.lineno.as_ref(py), _range.start.row.get())?;
+        instance.setattr(cache.col_offset.as_ref(py), _range.start.column.get())?;
+        if let Some(end) = _range.end {
+            instance.setattr(cache.end_lineno.as_ref(py), end.row.get())?;
+            instance.setattr(cache.end_col_offset.as_ref(py), end.column.get())?;
+        }
+
+        Ok(instance)
+    }
+}
+
 fn init_types(py: Python) -> PyResult<()> {
     let ast_module = PyModule::import(py, "_ast")?;
     cache_py_type::<ast::Mod>(ast_module)?;
@@ -4731,6 +4985,7 @@ fn init_types(py: Python) -> PyResult<()> {
     cache_py_type::<ast::StmtReturn>(ast_module)?;
     cache_py_type::<ast::StmtDelete>(ast_module)?;
     cache_py_type::<ast::StmtAssign>(ast_module)?;
+    cache_py_type::<ast::StmtTypeAlias>(ast_module)?;
     cache_py_type::<ast::StmtAugAssign>(ast_module)?;
     cache_py_type::<ast::StmtAnnAssign>(ast_module)?;
     cache_py_type::<ast::StmtFor>(ast_module)?;
@@ -4837,5 +5092,9 @@ fn init_types(py: Python) -> PyResult<()> {
     cache_py_type::<ast::PatternMatchOr>(ast_module)?;
     cache_py_type::<ast::TypeIgnore>(ast_module)?;
     cache_py_type::<ast::TypeIgnoreTypeIgnore>(ast_module)?;
+    cache_py_type::<ast::TypeParam>(ast_module)?;
+    cache_py_type::<ast::TypeParamTypeVar>(ast_module)?;
+    cache_py_type::<ast::TypeParamParamSpec>(ast_module)?;
+    cache_py_type::<ast::TypeParamTypeVarTuple>(ast_module)?;
     Ok(())
 }
diff --git a/ast-pyo3/src/gen/wrapper_located.rs b/ast-pyo3/src/gen/wrapper_located.rs
index 0aebc63a..b6d56dd7 100644
--- a/ast-pyo3/src/gen/wrapper_located.rs
+++ b/ast-pyo3/src/gen/wrapper_located.rs
@@ -222,6 +222,7 @@ impl ToPyWrapper for ast::Stmt<SourceRange> {
             Self::Return(cons) => cons.to_py_wrapper(py),
             Self::Delete(cons) => cons.to_py_wrapper(py),
             Self::Assign(cons) => cons.to_py_wrapper(py),
+            Self::TypeAlias(cons) => cons.to_py_wrapper(py),
             Self::AugAssign(cons) => cons.to_py_wrapper(py),
             Self::AnnAssign(cons) => cons.to_py_wrapper(py),
             Self::For(cons) => cons.to_py_wrapper(py),
@@ -310,6 +311,12 @@ impl StmtFunctionDef {
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
         self.0.type_comment.to_py_wrapper(py)
     }
+
+    #[getter]
+    #[inline]
+    fn get_type_params(&self, py: Python) -> PyResult<PyObject> {
+        self.0.type_params.to_py_wrapper(py)
+    }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_AsyncFunctionDef", extends=Stmt, frozen)]
@@ -375,6 +382,12 @@ impl StmtAsyncFunctionDef {
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
         self.0.type_comment.to_py_wrapper(py)
     }
+
+    #[getter]
+    #[inline]
+    fn get_type_params(&self, py: Python) -> PyResult<PyObject> {
+        self.0.type_params.to_py_wrapper(py)
+    }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_ClassDef", extends=Stmt, frozen)]
@@ -434,6 +447,12 @@ impl StmtClassDef {
     fn get_decorator_list(&self, py: Python) -> PyResult<PyObject> {
         self.0.decorator_list.to_py_wrapper(py)
     }
+
+    #[getter]
+    #[inline]
+    fn get_type_params(&self, py: Python) -> PyResult<PyObject> {
+        self.0.type_params.to_py_wrapper(py)
+    }
 }
 
 #[pyclass(module="rustpython_ast.located", name="_Return", extends=Stmt, frozen)]
@@ -553,6 +572,53 @@ impl StmtAssign {
     }
 }
 
+#[pyclass(module="rustpython_ast.located", name="_TypeAlias", extends=Stmt, frozen)]
+#[derive(Clone, Debug)]
+pub struct StmtTypeAlias(pub &'static ast::StmtTypeAlias<SourceRange>);
+
+impl From<&'static ast::StmtTypeAlias<SourceRange>> for StmtTypeAlias {
+    fn from(node: &'static ast::StmtTypeAlias<SourceRange>) -> Self {
+        StmtTypeAlias(node)
+    }
+}
+
+impl ToPyObject for StmtTypeAlias {
+    fn to_object(&self, py: Python) -> PyObject {
+        let initializer = PyClassInitializer::from(Ast)
+            .add_subclass(Stmt)
+            .add_subclass(self.clone());
+        Py::new(py, initializer).unwrap().into_py(py)
+    }
+}
+
+impl ToPyWrapper for ast::StmtTypeAlias<SourceRange> {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        Ok(StmtTypeAlias(self).to_object(py))
+    }
+}
+
+#[pymethods]
+impl StmtTypeAlias {
+    #[getter]
+    #[inline]
+    fn get_name(&self, py: Python) -> PyResult<PyObject> {
+        self.0.name.to_py_wrapper(py)
+    }
+
+    #[getter]
+    #[inline]
+    fn get_type_params(&self, py: Python) -> PyResult<PyObject> {
+        self.0.type_params.to_py_wrapper(py)
+    }
+
+    #[getter]
+    #[inline]
+    fn get_value(&self, py: Python) -> PyResult<PyObject> {
+        self.0.value.to_py_wrapper(py)
+    }
+}
+
 #[pyclass(module="rustpython_ast.located", name="_AugAssign", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
 pub struct StmtAugAssign(pub &'static ast::StmtAugAssign<SourceRange>);
@@ -3993,6 +4059,152 @@ impl TypeIgnoreTypeIgnore {
     }
 }
 
+#[pyclass(module="rustpython_ast.located", name="_type_param", extends=super::Ast, frozen, subclass)]
+#[derive(Clone, Debug)]
+pub struct TypeParam;
+
+impl From<&'static ast::TypeParam<SourceRange>> for TypeParam {
+    fn from(_node: &'static ast::TypeParam<SourceRange>) -> Self {
+        TypeParam
+    }
+}
+
+#[pymethods]
+impl TypeParam {
+    #[new]
+    fn new() -> PyClassInitializer<Self> {
+        PyClassInitializer::from(Ast).add_subclass(Self)
+    }
+}
+impl ToPyObject for TypeParam {
+    fn to_object(&self, py: Python) -> PyObject {
+        let initializer = Self::new();
+        Py::new(py, initializer).unwrap().into_py(py)
+    }
+}
+
+impl ToPyWrapper for ast::TypeParam<SourceRange> {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        match &self {
+            Self::TypeVar(cons) => cons.to_py_wrapper(py),
+            Self::ParamSpec(cons) => cons.to_py_wrapper(py),
+            Self::TypeVarTuple(cons) => cons.to_py_wrapper(py),
+        }
+    }
+}
+
+#[pyclass(module="rustpython_ast.located", name="_TypeVar", extends=TypeParam, frozen)]
+#[derive(Clone, Debug)]
+pub struct TypeParamTypeVar(pub &'static ast::TypeParamTypeVar<SourceRange>);
+
+impl From<&'static ast::TypeParamTypeVar<SourceRange>> for TypeParamTypeVar {
+    fn from(node: &'static ast::TypeParamTypeVar<SourceRange>) -> Self {
+        TypeParamTypeVar(node)
+    }
+}
+
+impl ToPyObject for TypeParamTypeVar {
+    fn to_object(&self, py: Python) -> PyObject {
+        let initializer = PyClassInitializer::from(Ast)
+            .add_subclass(TypeParam)
+            .add_subclass(self.clone());
+        Py::new(py, initializer).unwrap().into_py(py)
+    }
+}
+
+impl ToPyWrapper for ast::TypeParamTypeVar<SourceRange> {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        Ok(TypeParamTypeVar(self).to_object(py))
+    }
+}
+
+#[pymethods]
+impl TypeParamTypeVar {
+    #[getter]
+    #[inline]
+    fn get_name(&self, py: Python) -> PyResult<PyObject> {
+        self.0.name.to_py_wrapper(py)
+    }
+
+    #[getter]
+    #[inline]
+    fn get_bound(&self, py: Python) -> PyResult<PyObject> {
+        self.0.bound.to_py_wrapper(py)
+    }
+}
+
+#[pyclass(module="rustpython_ast.located", name="_ParamSpec", extends=TypeParam, frozen)]
+#[derive(Clone, Debug)]
+pub struct TypeParamParamSpec(pub &'static ast::TypeParamParamSpec<SourceRange>);
+
+impl From<&'static ast::TypeParamParamSpec<SourceRange>> for TypeParamParamSpec {
+    fn from(node: &'static ast::TypeParamParamSpec<SourceRange>) -> Self {
+        TypeParamParamSpec(node)
+    }
+}
+
+impl ToPyObject for TypeParamParamSpec {
+    fn to_object(&self, py: Python) -> PyObject {
+        let initializer = PyClassInitializer::from(Ast)
+            .add_subclass(TypeParam)
+            .add_subclass(self.clone());
+        Py::new(py, initializer).unwrap().into_py(py)
+    }
+}
+
+impl ToPyWrapper for ast::TypeParamParamSpec<SourceRange> {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        Ok(TypeParamParamSpec(self).to_object(py))
+    }
+}
+
+#[pymethods]
+impl TypeParamParamSpec {
+    #[getter]
+    #[inline]
+    fn get_name(&self, py: Python) -> PyResult<PyObject> {
+        self.0.name.to_py_wrapper(py)
+    }
+}
+
+#[pyclass(module="rustpython_ast.located", name="_TypeVarTuple", extends=TypeParam, frozen)]
+#[derive(Clone, Debug)]
+pub struct TypeParamTypeVarTuple(pub &'static ast::TypeParamTypeVarTuple<SourceRange>);
+
+impl From<&'static ast::TypeParamTypeVarTuple<SourceRange>> for TypeParamTypeVarTuple {
+    fn from(node: &'static ast::TypeParamTypeVarTuple<SourceRange>) -> Self {
+        TypeParamTypeVarTuple(node)
+    }
+}
+
+impl ToPyObject for TypeParamTypeVarTuple {
+    fn to_object(&self, py: Python) -> PyObject {
+        let initializer = PyClassInitializer::from(Ast)
+            .add_subclass(TypeParam)
+            .add_subclass(self.clone());
+        Py::new(py, initializer).unwrap().into_py(py)
+    }
+}
+
+impl ToPyWrapper for ast::TypeParamTypeVarTuple<SourceRange> {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        Ok(TypeParamTypeVarTuple(self).to_object(py))
+    }
+}
+
+#[pymethods]
+impl TypeParamTypeVarTuple {
+    #[getter]
+    #[inline]
+    fn get_name(&self, py: Python) -> PyResult<PyObject> {
+        self.0.name.to_py_wrapper(py)
+    }
+}
+
 impl ToPyWrapper for ast::ExprContext {
     #[inline]
     fn to_py_wrapper(&self, py: Python) -> PyResult<Py<PyAny>> {
@@ -4303,6 +4515,7 @@ pub fn add_to_module(py: Python, m: &PyModule) -> PyResult<()> {
     super::init_type::<StmtReturn, ast::StmtReturn>(py, m)?;
     super::init_type::<StmtDelete, ast::StmtDelete>(py, m)?;
     super::init_type::<StmtAssign, ast::StmtAssign>(py, m)?;
+    super::init_type::<StmtTypeAlias, ast::StmtTypeAlias>(py, m)?;
     super::init_type::<StmtAugAssign, ast::StmtAugAssign>(py, m)?;
     super::init_type::<StmtAnnAssign, ast::StmtAnnAssign>(py, m)?;
     super::init_type::<StmtFor, ast::StmtFor>(py, m)?;
@@ -4409,5 +4622,9 @@ pub fn add_to_module(py: Python, m: &PyModule) -> PyResult<()> {
     super::init_type::<PatternMatchOr, ast::PatternMatchOr>(py, m)?;
     super::init_type::<TypeIgnore, ast::TypeIgnore>(py, m)?;
     super::init_type::<TypeIgnoreTypeIgnore, ast::TypeIgnoreTypeIgnore>(py, m)?;
+    super::init_type::<TypeParam, ast::TypeParam>(py, m)?;
+    super::init_type::<TypeParamTypeVar, ast::TypeParamTypeVar>(py, m)?;
+    super::init_type::<TypeParamParamSpec, ast::TypeParamParamSpec>(py, m)?;
+    super::init_type::<TypeParamTypeVarTuple, ast::TypeParamTypeVarTuple>(py, m)?;
     Ok(())
 }
diff --git a/ast-pyo3/src/gen/wrapper_ranged.rs b/ast-pyo3/src/gen/wrapper_ranged.rs
index 8a405c2a..53416ad2 100644
--- a/ast-pyo3/src/gen/wrapper_ranged.rs
+++ b/ast-pyo3/src/gen/wrapper_ranged.rs
@@ -222,6 +222,7 @@ impl ToPyWrapper for ast::Stmt<TextRange> {
             Self::Return(cons) => cons.to_py_wrapper(py),
             Self::Delete(cons) => cons.to_py_wrapper(py),
             Self::Assign(cons) => cons.to_py_wrapper(py),
+            Self::TypeAlias(cons) => cons.to_py_wrapper(py),
             Self::AugAssign(cons) => cons.to_py_wrapper(py),
             Self::AnnAssign(cons) => cons.to_py_wrapper(py),
             Self::For(cons) => cons.to_py_wrapper(py),
@@ -310,6 +311,12 @@ impl StmtFunctionDef {
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
         self.0.type_comment.to_py_wrapper(py)
     }
+
+    #[getter]
+    #[inline]
+    fn get_type_params(&self, py: Python) -> PyResult<PyObject> {
+        self.0.type_params.to_py_wrapper(py)
+    }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_AsyncFunctionDef", extends=Stmt, frozen)]
@@ -375,6 +382,12 @@ impl StmtAsyncFunctionDef {
     fn get_type_comment(&self, py: Python) -> PyResult<PyObject> {
         self.0.type_comment.to_py_wrapper(py)
     }
+
+    #[getter]
+    #[inline]
+    fn get_type_params(&self, py: Python) -> PyResult<PyObject> {
+        self.0.type_params.to_py_wrapper(py)
+    }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_ClassDef", extends=Stmt, frozen)]
@@ -434,6 +447,12 @@ impl StmtClassDef {
     fn get_decorator_list(&self, py: Python) -> PyResult<PyObject> {
         self.0.decorator_list.to_py_wrapper(py)
     }
+
+    #[getter]
+    #[inline]
+    fn get_type_params(&self, py: Python) -> PyResult<PyObject> {
+        self.0.type_params.to_py_wrapper(py)
+    }
 }
 
 #[pyclass(module="rustpython_ast.ranged", name="_Return", extends=Stmt, frozen)]
@@ -553,6 +572,53 @@ impl StmtAssign {
     }
 }
 
+#[pyclass(module="rustpython_ast.ranged", name="_TypeAlias", extends=Stmt, frozen)]
+#[derive(Clone, Debug)]
+pub struct StmtTypeAlias(pub &'static ast::StmtTypeAlias<TextRange>);
+
+impl From<&'static ast::StmtTypeAlias<TextRange>> for StmtTypeAlias {
+    fn from(node: &'static ast::StmtTypeAlias<TextRange>) -> Self {
+        StmtTypeAlias(node)
+    }
+}
+
+impl ToPyObject for StmtTypeAlias {
+    fn to_object(&self, py: Python) -> PyObject {
+        let initializer = PyClassInitializer::from(Ast)
+            .add_subclass(Stmt)
+            .add_subclass(self.clone());
+        Py::new(py, initializer).unwrap().into_py(py)
+    }
+}
+
+impl ToPyWrapper for ast::StmtTypeAlias<TextRange> {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        Ok(StmtTypeAlias(self).to_object(py))
+    }
+}
+
+#[pymethods]
+impl StmtTypeAlias {
+    #[getter]
+    #[inline]
+    fn get_name(&self, py: Python) -> PyResult<PyObject> {
+        self.0.name.to_py_wrapper(py)
+    }
+
+    #[getter]
+    #[inline]
+    fn get_type_params(&self, py: Python) -> PyResult<PyObject> {
+        self.0.type_params.to_py_wrapper(py)
+    }
+
+    #[getter]
+    #[inline]
+    fn get_value(&self, py: Python) -> PyResult<PyObject> {
+        self.0.value.to_py_wrapper(py)
+    }
+}
+
 #[pyclass(module="rustpython_ast.ranged", name="_AugAssign", extends=Stmt, frozen)]
 #[derive(Clone, Debug)]
 pub struct StmtAugAssign(pub &'static ast::StmtAugAssign<TextRange>);
@@ -3993,6 +4059,152 @@ impl TypeIgnoreTypeIgnore {
     }
 }
 
+#[pyclass(module="rustpython_ast.ranged", name="_type_param", extends=super::Ast, frozen, subclass)]
+#[derive(Clone, Debug)]
+pub struct TypeParam;
+
+impl From<&'static ast::TypeParam<TextRange>> for TypeParam {
+    fn from(_node: &'static ast::TypeParam<TextRange>) -> Self {
+        TypeParam
+    }
+}
+
+#[pymethods]
+impl TypeParam {
+    #[new]
+    fn new() -> PyClassInitializer<Self> {
+        PyClassInitializer::from(Ast).add_subclass(Self)
+    }
+}
+impl ToPyObject for TypeParam {
+    fn to_object(&self, py: Python) -> PyObject {
+        let initializer = Self::new();
+        Py::new(py, initializer).unwrap().into_py(py)
+    }
+}
+
+impl ToPyWrapper for ast::TypeParam<TextRange> {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        match &self {
+            Self::TypeVar(cons) => cons.to_py_wrapper(py),
+            Self::ParamSpec(cons) => cons.to_py_wrapper(py),
+            Self::TypeVarTuple(cons) => cons.to_py_wrapper(py),
+        }
+    }
+}
+
+#[pyclass(module="rustpython_ast.ranged", name="_TypeVar", extends=TypeParam, frozen)]
+#[derive(Clone, Debug)]
+pub struct TypeParamTypeVar(pub &'static ast::TypeParamTypeVar<TextRange>);
+
+impl From<&'static ast::TypeParamTypeVar<TextRange>> for TypeParamTypeVar {
+    fn from(node: &'static ast::TypeParamTypeVar<TextRange>) -> Self {
+        TypeParamTypeVar(node)
+    }
+}
+
+impl ToPyObject for TypeParamTypeVar {
+    fn to_object(&self, py: Python) -> PyObject {
+        let initializer = PyClassInitializer::from(Ast)
+            .add_subclass(TypeParam)
+            .add_subclass(self.clone());
+        Py::new(py, initializer).unwrap().into_py(py)
+    }
+}
+
+impl ToPyWrapper for ast::TypeParamTypeVar<TextRange> {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        Ok(TypeParamTypeVar(self).to_object(py))
+    }
+}
+
+#[pymethods]
+impl TypeParamTypeVar {
+    #[getter]
+    #[inline]
+    fn get_name(&self, py: Python) -> PyResult<PyObject> {
+        self.0.name.to_py_wrapper(py)
+    }
+
+    #[getter]
+    #[inline]
+    fn get_bound(&self, py: Python) -> PyResult<PyObject> {
+        self.0.bound.to_py_wrapper(py)
+    }
+}
+
+#[pyclass(module="rustpython_ast.ranged", name="_ParamSpec", extends=TypeParam, frozen)]
+#[derive(Clone, Debug)]
+pub struct TypeParamParamSpec(pub &'static ast::TypeParamParamSpec<TextRange>);
+
+impl From<&'static ast::TypeParamParamSpec<TextRange>> for TypeParamParamSpec {
+    fn from(node: &'static ast::TypeParamParamSpec<TextRange>) -> Self {
+        TypeParamParamSpec(node)
+    }
+}
+
+impl ToPyObject for TypeParamParamSpec {
+    fn to_object(&self, py: Python) -> PyObject {
+        let initializer = PyClassInitializer::from(Ast)
+            .add_subclass(TypeParam)
+            .add_subclass(self.clone());
+        Py::new(py, initializer).unwrap().into_py(py)
+    }
+}
+
+impl ToPyWrapper for ast::TypeParamParamSpec<TextRange> {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        Ok(TypeParamParamSpec(self).to_object(py))
+    }
+}
+
+#[pymethods]
+impl TypeParamParamSpec {
+    #[getter]
+    #[inline]
+    fn get_name(&self, py: Python) -> PyResult<PyObject> {
+        self.0.name.to_py_wrapper(py)
+    }
+}
+
+#[pyclass(module="rustpython_ast.ranged", name="_TypeVarTuple", extends=TypeParam, frozen)]
+#[derive(Clone, Debug)]
+pub struct TypeParamTypeVarTuple(pub &'static ast::TypeParamTypeVarTuple<TextRange>);
+
+impl From<&'static ast::TypeParamTypeVarTuple<TextRange>> for TypeParamTypeVarTuple {
+    fn from(node: &'static ast::TypeParamTypeVarTuple<TextRange>) -> Self {
+        TypeParamTypeVarTuple(node)
+    }
+}
+
+impl ToPyObject for TypeParamTypeVarTuple {
+    fn to_object(&self, py: Python) -> PyObject {
+        let initializer = PyClassInitializer::from(Ast)
+            .add_subclass(TypeParam)
+            .add_subclass(self.clone());
+        Py::new(py, initializer).unwrap().into_py(py)
+    }
+}
+
+impl ToPyWrapper for ast::TypeParamTypeVarTuple<TextRange> {
+    #[inline]
+    fn to_py_wrapper(&'static self, py: Python) -> PyResult<Py<PyAny>> {
+        Ok(TypeParamTypeVarTuple(self).to_object(py))
+    }
+}
+
+#[pymethods]
+impl TypeParamTypeVarTuple {
+    #[getter]
+    #[inline]
+    fn get_name(&self, py: Python) -> PyResult<PyObject> {
+        self.0.name.to_py_wrapper(py)
+    }
+}
+
 pub fn add_to_module(py: Python, m: &PyModule) -> PyResult<()> {
     super::init_module(py, m)?;
     super::init_type::<Mod, ast::Mod>(py, m)?;
@@ -4007,6 +4219,7 @@ pub fn add_to_module(py: Python, m: &PyModule) -> PyResult<()> {
     super::init_type::<StmtReturn, ast::StmtReturn>(py, m)?;
     super::init_type::<StmtDelete, ast::StmtDelete>(py, m)?;
     super::init_type::<StmtAssign, ast::StmtAssign>(py, m)?;
+    super::init_type::<StmtTypeAlias, ast::StmtTypeAlias>(py, m)?;
     super::init_type::<StmtAugAssign, ast::StmtAugAssign>(py, m)?;
     super::init_type::<StmtAnnAssign, ast::StmtAnnAssign>(py, m)?;
     super::init_type::<StmtFor, ast::StmtFor>(py, m)?;
@@ -4113,5 +4326,9 @@ pub fn add_to_module(py: Python, m: &PyModule) -> PyResult<()> {
     super::init_type::<PatternMatchOr, ast::PatternMatchOr>(py, m)?;
     super::init_type::<TypeIgnore, ast::TypeIgnore>(py, m)?;
     super::init_type::<TypeIgnoreTypeIgnore, ast::TypeIgnoreTypeIgnore>(py, m)?;
+    super::init_type::<TypeParam, ast::TypeParam>(py, m)?;
+    super::init_type::<TypeParamTypeVar, ast::TypeParamTypeVar>(py, m)?;
+    super::init_type::<TypeParamParamSpec, ast::TypeParamParamSpec>(py, m)?;
+    super::init_type::<TypeParamTypeVarTuple, ast::TypeParamTypeVarTuple>(py, m)?;
     Ok(())
 }
diff --git a/ast/src/gen/fold.rs b/ast/src/gen/fold.rs
index 5fe48e90..b133b891 100644
--- a/ast/src/gen/fold.rs
+++ b/ast/src/gen/fold.rs
@@ -108,6 +108,12 @@ pub trait Fold<U> {
     ) -> Result<StmtAssign<Self::TargetU>, Self::Error> {
         fold_stmt_assign(self, node)
     }
+    fn fold_stmt_type_alias(
+        &mut self,
+        node: StmtTypeAlias<U>,
+    ) -> Result<StmtTypeAlias<Self::TargetU>, Self::Error> {
+        fold_stmt_type_alias(self, node)
+    }
     fn fold_stmt_aug_assign(
         &mut self,
         node: StmtAugAssign<U>,
@@ -507,6 +513,30 @@ pub trait Fold<U> {
     ) -> Result<TypeIgnoreTypeIgnore<Self::TargetU>, Self::Error> {
         fold_type_ignore_type_ignore(self, node)
     }
+    fn fold_type_param(
+        &mut self,
+        node: TypeParam<U>,
+    ) -> Result<TypeParam<Self::TargetU>, Self::Error> {
+        fold_type_param(self, node)
+    }
+    fn fold_type_param_type_var(
+        &mut self,
+        node: TypeParamTypeVar<U>,
+    ) -> Result<TypeParamTypeVar<Self::TargetU>, Self::Error> {
+        fold_type_param_type_var(self, node)
+    }
+    fn fold_type_param_param_spec(
+        &mut self,
+        node: TypeParamParamSpec<U>,
+    ) -> Result<TypeParamParamSpec<Self::TargetU>, Self::Error> {
+        fold_type_param_param_spec(self, node)
+    }
+    fn fold_type_param_type_var_tuple(
+        &mut self,
+        node: TypeParamTypeVarTuple<U>,
+    ) -> Result<TypeParamTypeVarTuple<Self::TargetU>, Self::Error> {
+        fold_type_param_type_var_tuple(self, node)
+    }
     fn fold_arg_with_default(
         &mut self,
         node: ArgWithDefault<U>,
@@ -653,6 +683,7 @@ pub fn fold_stmt<U, F: Fold<U> + ?Sized>(
         Stmt::Return(cons) => Stmt::Return(Foldable::fold(cons, folder)?),
         Stmt::Delete(cons) => Stmt::Delete(Foldable::fold(cons, folder)?),
         Stmt::Assign(cons) => Stmt::Assign(Foldable::fold(cons, folder)?),
+        Stmt::TypeAlias(cons) => Stmt::TypeAlias(Foldable::fold(cons, folder)?),
         Stmt::AugAssign(cons) => Stmt::AugAssign(Foldable::fold(cons, folder)?),
         Stmt::AnnAssign(cons) => Stmt::AnnAssign(Foldable::fold(cons, folder)?),
         Stmt::For(cons) => Stmt::For(Foldable::fold(cons, folder)?),
@@ -697,6 +728,7 @@ pub fn fold_stmt_function_def<U, F: Fold<U> + ?Sized>(
         decorator_list,
         returns,
         type_comment,
+        type_params,
         range,
     } = node;
     let context = folder.will_map_user(&range);
@@ -707,6 +739,7 @@ pub fn fold_stmt_function_def<U, F: Fold<U> + ?Sized>(
     let decorator_list = Foldable::fold(decorator_list, folder)?;
     let returns = Foldable::fold(returns, folder)?;
     let type_comment = Foldable::fold(type_comment, folder)?;
+    let type_params = Foldable::fold(type_params, folder)?;
     let range = folder.map_user(range, context)?;
     Ok(StmtFunctionDef {
         name,
@@ -715,6 +748,7 @@ pub fn fold_stmt_function_def<U, F: Fold<U> + ?Sized>(
         decorator_list,
         returns,
         type_comment,
+        type_params,
         range,
     })
 }
@@ -738,6 +772,7 @@ pub fn fold_stmt_async_function_def<U, F: Fold<U> + ?Sized>(
         decorator_list,
         returns,
         type_comment,
+        type_params,
         range,
     } = node;
     let context = folder.will_map_user(&range);
@@ -748,6 +783,7 @@ pub fn fold_stmt_async_function_def<U, F: Fold<U> + ?Sized>(
     let decorator_list = Foldable::fold(decorator_list, folder)?;
     let returns = Foldable::fold(returns, folder)?;
     let type_comment = Foldable::fold(type_comment, folder)?;
+    let type_params = Foldable::fold(type_params, folder)?;
     let range = folder.map_user(range, context)?;
     Ok(StmtAsyncFunctionDef {
         name,
@@ -756,6 +792,7 @@ pub fn fold_stmt_async_function_def<U, F: Fold<U> + ?Sized>(
         decorator_list,
         returns,
         type_comment,
+        type_params,
         range,
     })
 }
@@ -778,6 +815,7 @@ pub fn fold_stmt_class_def<U, F: Fold<U> + ?Sized>(
         keywords,
         body,
         decorator_list,
+        type_params,
         range,
     } = node;
     let context = folder.will_map_user(&range);
@@ -787,6 +825,7 @@ pub fn fold_stmt_class_def<U, F: Fold<U> + ?Sized>(
     let keywords = Foldable::fold(keywords, folder)?;
     let body = Foldable::fold(body, folder)?;
     let decorator_list = Foldable::fold(decorator_list, folder)?;
+    let type_params = Foldable::fold(type_params, folder)?;
     let range = folder.map_user(range, context)?;
     Ok(StmtClassDef {
         name,
@@ -794,6 +833,7 @@ pub fn fold_stmt_class_def<U, F: Fold<U> + ?Sized>(
         keywords,
         body,
         decorator_list,
+        type_params,
         range,
     })
 }
@@ -869,6 +909,38 @@ pub fn fold_stmt_assign<U, F: Fold<U> + ?Sized>(
         range,
     })
 }
+impl<T, U> Foldable<T, U> for StmtTypeAlias<T> {
+    type Mapped = StmtTypeAlias<U>;
+    fn fold<F: Fold<T, TargetU = U> + ?Sized>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self::Mapped, F::Error> {
+        folder.fold_stmt_type_alias(self)
+    }
+}
+pub fn fold_stmt_type_alias<U, F: Fold<U> + ?Sized>(
+    #[allow(unused)] folder: &mut F,
+    node: StmtTypeAlias<U>,
+) -> Result<StmtTypeAlias<F::TargetU>, F::Error> {
+    let StmtTypeAlias {
+        name,
+        type_params,
+        value,
+        range,
+    } = node;
+    let context = folder.will_map_user(&range);
+
+    let name = Foldable::fold(name, folder)?;
+    let type_params = Foldable::fold(type_params, folder)?;
+    let value = Foldable::fold(value, folder)?;
+    let range = folder.map_user(range, context)?;
+    Ok(StmtTypeAlias {
+        name,
+        type_params,
+        value,
+        range,
+    })
+}
 impl<T, U> Foldable<T, U> for StmtAugAssign<T> {
     type Mapped = StmtAugAssign<U>;
     fn fold<F: Fold<T, TargetU = U> + ?Sized>(
@@ -2791,6 +2863,87 @@ pub fn fold_type_ignore_type_ignore<U, F: Fold<U> + ?Sized>(
     let range = folder.map_user_cfg(range, context)?;
     Ok(TypeIgnoreTypeIgnore { lineno, tag, range })
 }
+impl<T, U> Foldable<T, U> for TypeParam<T> {
+    type Mapped = TypeParam<U>;
+    fn fold<F: Fold<T, TargetU = U> + ?Sized>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self::Mapped, F::Error> {
+        folder.fold_type_param(self)
+    }
+}
+pub fn fold_type_param<U, F: Fold<U> + ?Sized>(
+    #[allow(unused)] folder: &mut F,
+    node: TypeParam<U>,
+) -> Result<TypeParam<F::TargetU>, F::Error> {
+    let folded = match node {
+        TypeParam::TypeVar(cons) => TypeParam::TypeVar(Foldable::fold(cons, folder)?),
+        TypeParam::ParamSpec(cons) => TypeParam::ParamSpec(Foldable::fold(cons, folder)?),
+        TypeParam::TypeVarTuple(cons) => TypeParam::TypeVarTuple(Foldable::fold(cons, folder)?),
+    };
+    Ok(folded)
+}
+impl<T, U> Foldable<T, U> for TypeParamTypeVar<T> {
+    type Mapped = TypeParamTypeVar<U>;
+    fn fold<F: Fold<T, TargetU = U> + ?Sized>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self::Mapped, F::Error> {
+        folder.fold_type_param_type_var(self)
+    }
+}
+pub fn fold_type_param_type_var<U, F: Fold<U> + ?Sized>(
+    #[allow(unused)] folder: &mut F,
+    node: TypeParamTypeVar<U>,
+) -> Result<TypeParamTypeVar<F::TargetU>, F::Error> {
+    let TypeParamTypeVar { name, bound, range } = node;
+    let context = folder.will_map_user(&range);
+
+    let name = Foldable::fold(name, folder)?;
+    let bound = Foldable::fold(bound, folder)?;
+    let range = folder.map_user(range, context)?;
+    Ok(TypeParamTypeVar { name, bound, range })
+}
+impl<T, U> Foldable<T, U> for TypeParamParamSpec<T> {
+    type Mapped = TypeParamParamSpec<U>;
+    fn fold<F: Fold<T, TargetU = U> + ?Sized>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self::Mapped, F::Error> {
+        folder.fold_type_param_param_spec(self)
+    }
+}
+pub fn fold_type_param_param_spec<U, F: Fold<U> + ?Sized>(
+    #[allow(unused)] folder: &mut F,
+    node: TypeParamParamSpec<U>,
+) -> Result<TypeParamParamSpec<F::TargetU>, F::Error> {
+    let TypeParamParamSpec { name, range } = node;
+    let context = folder.will_map_user(&range);
+
+    let name = Foldable::fold(name, folder)?;
+    let range = folder.map_user(range, context)?;
+    Ok(TypeParamParamSpec { name, range })
+}
+impl<T, U> Foldable<T, U> for TypeParamTypeVarTuple<T> {
+    type Mapped = TypeParamTypeVarTuple<U>;
+    fn fold<F: Fold<T, TargetU = U> + ?Sized>(
+        self,
+        folder: &mut F,
+    ) -> Result<Self::Mapped, F::Error> {
+        folder.fold_type_param_type_var_tuple(self)
+    }
+}
+pub fn fold_type_param_type_var_tuple<U, F: Fold<U> + ?Sized>(
+    #[allow(unused)] folder: &mut F,
+    node: TypeParamTypeVarTuple<U>,
+) -> Result<TypeParamTypeVarTuple<F::TargetU>, F::Error> {
+    let TypeParamTypeVarTuple { name, range } = node;
+    let context = folder.will_map_user(&range);
+
+    let name = Foldable::fold(name, folder)?;
+    let range = folder.map_user(range, context)?;
+    Ok(TypeParamTypeVarTuple { name, range })
+}
 impl<T, U> Foldable<T, U> for ArgWithDefault<T> {
     type Mapped = ArgWithDefault<U>;
     fn fold<F: Fold<T, TargetU = U> + ?Sized>(
diff --git a/ast/src/gen/generic.rs b/ast/src/gen/generic.rs
index 3b193ec2..5efe9c05 100644
--- a/ast/src/gen/generic.rs
+++ b/ast/src/gen/generic.rs
@@ -1,8 +1,7 @@
 // File automatically generated by ast/asdl_rs.py.
 
 use crate::text_size::TextRange;
-#[derive(Clone, Debug, PartialEq)]
-#[derive(is_macro::Is)]
+#[derive(Clone, Debug, PartialEq, is_macro::Is)]
 pub enum Ast<R = TextRange> {
     #[is(name = "module")]
     Mod(Mod<R>),
@@ -23,6 +22,7 @@ pub enum Ast<R = TextRange> {
     MatchCase(MatchCase<R>),
     Pattern(Pattern<R>),
     TypeIgnore(TypeIgnore<R>),
+    TypeParam(TypeParam<R>),
 }
 impl<R> Node for Ast<R> {
     const NAME: &'static str = "AST";
@@ -137,6 +137,12 @@ impl<R> From<TypeIgnore<R>> for Ast<R> {
     }
 }
 
+impl<R> From<TypeParam<R>> for Ast<R> {
+    fn from(node: TypeParam<R>) -> Self {
+        Ast::TypeParam(node)
+    }
+}
+
 /// See also [mod](https://docs.python.org/3/library/ast.html#ast.mod)
 #[derive(Clone, Debug, PartialEq, is_macro::Is)]
 pub enum Mod<R = TextRange> {
@@ -256,6 +262,8 @@ pub enum Stmt<R = TextRange> {
     Delete(StmtDelete<R>),
     #[is(name = "assign_stmt")]
     Assign(StmtAssign<R>),
+    #[is(name = "type_alias_stmt")]
+    TypeAlias(StmtTypeAlias<R>),
     #[is(name = "aug_assign_stmt")]
     AugAssign(StmtAugAssign<R>),
     #[is(name = "ann_assign_stmt")]
@@ -310,6 +318,7 @@ pub struct StmtFunctionDef<R = TextRange> {
     pub decorator_list: Vec<Expr<R>>,
     pub returns: Option<Box<Expr<R>>>,
     pub type_comment: Option<String>,
+    pub type_params: Vec<TypeParam<R>>,
 }
 
 impl<R> Node for StmtFunctionDef<R> {
@@ -321,6 +330,7 @@ impl<R> Node for StmtFunctionDef<R> {
         "decorator_list",
         "returns",
         "type_comment",
+        "type_params",
     ];
 }
 impl<R> From<StmtFunctionDef<R>> for Stmt<R> {
@@ -344,6 +354,7 @@ pub struct StmtAsyncFunctionDef<R = TextRange> {
     pub decorator_list: Vec<Expr<R>>,
     pub returns: Option<Box<Expr<R>>>,
     pub type_comment: Option<String>,
+    pub type_params: Vec<TypeParam<R>>,
 }
 
 impl<R> Node for StmtAsyncFunctionDef<R> {
@@ -355,6 +366,7 @@ impl<R> Node for StmtAsyncFunctionDef<R> {
         "decorator_list",
         "returns",
         "type_comment",
+        "type_params",
     ];
 }
 impl<R> From<StmtAsyncFunctionDef<R>> for Stmt<R> {
@@ -377,12 +389,19 @@ pub struct StmtClassDef<R = TextRange> {
     pub keywords: Vec<Keyword<R>>,
     pub body: Vec<Stmt<R>>,
     pub decorator_list: Vec<Expr<R>>,
+    pub type_params: Vec<TypeParam<R>>,
 }
 
 impl<R> Node for StmtClassDef<R> {
     const NAME: &'static str = "ClassDef";
-    const FIELD_NAMES: &'static [&'static str] =
-        &["name", "bases", "keywords", "body", "decorator_list"];
+    const FIELD_NAMES: &'static [&'static str] = &[
+        "name",
+        "bases",
+        "keywords",
+        "body",
+        "decorator_list",
+        "type_params",
+    ];
 }
 impl<R> From<StmtClassDef<R>> for Stmt<R> {
     fn from(payload: StmtClassDef<R>) -> Self {
@@ -463,6 +482,30 @@ impl<R> From<StmtAssign<R>> for Ast<R> {
     }
 }
 
+/// See also [TypeAlias](https://docs.python.org/3/library/ast.html#ast.TypeAlias)
+#[derive(Clone, Debug, PartialEq)]
+pub struct StmtTypeAlias<R = TextRange> {
+    pub range: R,
+    pub name: Box<Expr<R>>,
+    pub type_params: Vec<TypeParam<R>>,
+    pub value: Box<Expr<R>>,
+}
+
+impl<R> Node for StmtTypeAlias<R> {
+    const NAME: &'static str = "TypeAlias";
+    const FIELD_NAMES: &'static [&'static str] = &["name", "type_params", "value"];
+}
+impl<R> From<StmtTypeAlias<R>> for Stmt<R> {
+    fn from(payload: StmtTypeAlias<R>) -> Self {
+        Stmt::TypeAlias(payload)
+    }
+}
+impl<R> From<StmtTypeAlias<R>> for Ast<R> {
+    fn from(payload: StmtTypeAlias<R>) -> Self {
+        Stmt::from(payload).into()
+    }
+}
+
 /// See also [AugAssign](https://docs.python.org/3/library/ast.html#ast.AugAssign)
 #[derive(Clone, Debug, PartialEq)]
 pub struct StmtAugAssign<R = TextRange> {
@@ -3074,6 +3117,86 @@ impl<R> Node for TypeIgnore<R> {
     const FIELD_NAMES: &'static [&'static str] = &[];
 }
 
+/// See also [type_param](https://docs.python.org/3/library/ast.html#ast.type_param)
+#[derive(Clone, Debug, PartialEq, is_macro::Is)]
+pub enum TypeParam<R = TextRange> {
+    TypeVar(TypeParamTypeVar<R>),
+    ParamSpec(TypeParamParamSpec<R>),
+    TypeVarTuple(TypeParamTypeVarTuple<R>),
+}
+
+/// See also [TypeVar](https://docs.python.org/3/library/ast.html#ast.TypeVar)
+#[derive(Clone, Debug, PartialEq)]
+pub struct TypeParamTypeVar<R = TextRange> {
+    pub range: R,
+    pub name: Identifier,
+    pub bound: Option<Box<Expr<R>>>,
+}
+
+impl<R> Node for TypeParamTypeVar<R> {
+    const NAME: &'static str = "TypeVar";
+    const FIELD_NAMES: &'static [&'static str] = &["name", "bound"];
+}
+impl<R> From<TypeParamTypeVar<R>> for TypeParam<R> {
+    fn from(payload: TypeParamTypeVar<R>) -> Self {
+        TypeParam::TypeVar(payload)
+    }
+}
+impl<R> From<TypeParamTypeVar<R>> for Ast<R> {
+    fn from(payload: TypeParamTypeVar<R>) -> Self {
+        TypeParam::from(payload).into()
+    }
+}
+
+/// See also [ParamSpec](https://docs.python.org/3/library/ast.html#ast.ParamSpec)
+#[derive(Clone, Debug, PartialEq)]
+pub struct TypeParamParamSpec<R = TextRange> {
+    pub range: R,
+    pub name: Identifier,
+}
+
+impl<R> Node for TypeParamParamSpec<R> {
+    const NAME: &'static str = "ParamSpec";
+    const FIELD_NAMES: &'static [&'static str] = &["name"];
+}
+impl<R> From<TypeParamParamSpec<R>> for TypeParam<R> {
+    fn from(payload: TypeParamParamSpec<R>) -> Self {
+        TypeParam::ParamSpec(payload)
+    }
+}
+impl<R> From<TypeParamParamSpec<R>> for Ast<R> {
+    fn from(payload: TypeParamParamSpec<R>) -> Self {
+        TypeParam::from(payload).into()
+    }
+}
+
+/// See also [TypeVarTuple](https://docs.python.org/3/library/ast.html#ast.TypeVarTuple)
+#[derive(Clone, Debug, PartialEq)]
+pub struct TypeParamTypeVarTuple<R = TextRange> {
+    pub range: R,
+    pub name: Identifier,
+}
+
+impl<R> Node for TypeParamTypeVarTuple<R> {
+    const NAME: &'static str = "TypeVarTuple";
+    const FIELD_NAMES: &'static [&'static str] = &["name"];
+}
+impl<R> From<TypeParamTypeVarTuple<R>> for TypeParam<R> {
+    fn from(payload: TypeParamTypeVarTuple<R>) -> Self {
+        TypeParam::TypeVarTuple(payload)
+    }
+}
+impl<R> From<TypeParamTypeVarTuple<R>> for Ast<R> {
+    fn from(payload: TypeParamTypeVarTuple<R>) -> Self {
+        TypeParam::from(payload).into()
+    }
+}
+
+impl<R> Node for TypeParam<R> {
+    const NAME: &'static str = "type_param";
+    const FIELD_NAMES: &'static [&'static str] = &[];
+}
+
 /// An alternative type of AST `arguments`. This is parser-friendly and human-friendly definition of function arguments.
 /// This form also has advantage to implement pre-order traverse.
 /// `defaults` and `kw_defaults` fields are removed and the default values are placed under each `arg_with_default` typed argument.
diff --git a/ast/src/gen/located.rs b/ast/src/gen/located.rs
index 63a7b474..7376652f 100644
--- a/ast/src/gen/located.rs
+++ b/ast/src/gen/located.rs
@@ -171,6 +171,20 @@ impl LocatedMut for StmtAssign {
     }
 }
 
+pub type StmtTypeAlias = crate::generic::StmtTypeAlias<SourceRange>;
+
+impl Located for StmtTypeAlias {
+    fn range(&self) -> SourceRange {
+        self.range
+    }
+}
+
+impl LocatedMut for StmtTypeAlias {
+    fn range_mut(&mut self) -> &mut SourceRange {
+        &mut self.range
+    }
+}
+
 pub type StmtAugAssign = crate::generic::StmtAugAssign<SourceRange>;
 
 impl Located for StmtAugAssign {
@@ -474,6 +488,7 @@ impl Located for Stmt {
             Self::Return(node) => node.range(),
             Self::Delete(node) => node.range(),
             Self::Assign(node) => node.range(),
+            Self::TypeAlias(node) => node.range(),
             Self::AugAssign(node) => node.range(),
             Self::AnnAssign(node) => node.range(),
             Self::For(node) => node.range(),
@@ -508,6 +523,7 @@ impl LocatedMut for Stmt {
             Self::Return(node) => node.range_mut(),
             Self::Delete(node) => node.range_mut(),
             Self::Assign(node) => node.range_mut(),
+            Self::TypeAlias(node) => node.range_mut(),
             Self::AugAssign(node) => node.range_mut(),
             Self::AnnAssign(node) => node.range_mut(),
             Self::For(node) => node.range_mut(),
@@ -1367,6 +1383,70 @@ impl LocatedMut for TypeIgnore {
     }
 }
 
+pub type TypeParam = crate::generic::TypeParam<SourceRange>;
+
+pub type TypeParamTypeVar = crate::generic::TypeParamTypeVar<SourceRange>;
+
+impl Located for TypeParamTypeVar {
+    fn range(&self) -> SourceRange {
+        self.range
+    }
+}
+
+impl LocatedMut for TypeParamTypeVar {
+    fn range_mut(&mut self) -> &mut SourceRange {
+        &mut self.range
+    }
+}
+
+pub type TypeParamParamSpec = crate::generic::TypeParamParamSpec<SourceRange>;
+
+impl Located for TypeParamParamSpec {
+    fn range(&self) -> SourceRange {
+        self.range
+    }
+}
+
+impl LocatedMut for TypeParamParamSpec {
+    fn range_mut(&mut self) -> &mut SourceRange {
+        &mut self.range
+    }
+}
+
+pub type TypeParamTypeVarTuple = crate::generic::TypeParamTypeVarTuple<SourceRange>;
+
+impl Located for TypeParamTypeVarTuple {
+    fn range(&self) -> SourceRange {
+        self.range
+    }
+}
+
+impl LocatedMut for TypeParamTypeVarTuple {
+    fn range_mut(&mut self) -> &mut SourceRange {
+        &mut self.range
+    }
+}
+
+impl Located for TypeParam {
+    fn range(&self) -> SourceRange {
+        match self {
+            Self::TypeVar(node) => node.range(),
+            Self::ParamSpec(node) => node.range(),
+            Self::TypeVarTuple(node) => node.range(),
+        }
+    }
+}
+
+impl LocatedMut for TypeParam {
+    fn range_mut(&mut self) -> &mut SourceRange {
+        match self {
+            Self::TypeVar(node) => node.range_mut(),
+            Self::ParamSpec(node) => node.range_mut(),
+            Self::TypeVarTuple(node) => node.range_mut(),
+        }
+    }
+}
+
 pub type Arguments = crate::generic::Arguments<SourceRange>;
 
 #[cfg(feature = "all-nodes-with-ranges")]
diff --git a/ast/src/gen/ranged.rs b/ast/src/gen/ranged.rs
index c6a2ea35..5d48ff3d 100644
--- a/ast/src/gen/ranged.rs
+++ b/ast/src/gen/ranged.rs
@@ -66,6 +66,11 @@ impl Ranged for crate::generic::StmtAssign<TextRange> {
         self.range
     }
 }
+impl Ranged for crate::generic::StmtTypeAlias<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
 impl Ranged for crate::generic::StmtAugAssign<TextRange> {
     fn range(&self) -> TextRange {
         self.range
@@ -180,6 +185,7 @@ impl Ranged for crate::Stmt {
             Self::Return(node) => node.range(),
             Self::Delete(node) => node.range(),
             Self::Assign(node) => node.range(),
+            Self::TypeAlias(node) => node.range(),
             Self::AugAssign(node) => node.range(),
             Self::AnnAssign(node) => node.range(),
             Self::For(node) => node.range(),
@@ -496,6 +502,31 @@ impl Ranged for crate::TypeIgnore {
     }
 }
 
+impl Ranged for crate::generic::TypeParamTypeVar<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::TypeParamParamSpec<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::generic::TypeParamTypeVarTuple<TextRange> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+impl Ranged for crate::TypeParam {
+    fn range(&self) -> TextRange {
+        match self {
+            Self::TypeVar(node) => node.range(),
+            Self::ParamSpec(node) => node.range(),
+            Self::TypeVarTuple(node) => node.range(),
+        }
+    }
+}
+
 #[cfg(feature = "all-nodes-with-ranges")]
 impl Ranged for crate::generic::Arguments<TextRange> {
     fn range(&self) -> TextRange {
diff --git a/ast/src/gen/visitor.rs b/ast/src/gen/visitor.rs
index af5fcabe..d84e5423 100644
--- a/ast/src/gen/visitor.rs
+++ b/ast/src/gen/visitor.rs
@@ -13,6 +13,7 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             Stmt::Return(data) => self.visit_stmt_return(data),
             Stmt::Delete(data) => self.visit_stmt_delete(data),
             Stmt::Assign(data) => self.visit_stmt_assign(data),
+            Stmt::TypeAlias(data) => self.visit_stmt_type_alias(data),
             Stmt::AugAssign(data) => self.visit_stmt_aug_assign(data),
             Stmt::AnnAssign(data) => self.visit_stmt_ann_assign(data),
             Stmt::For(data) => self.visit_stmt_for(data),
@@ -53,6 +54,9 @@ pub trait Visitor<R = crate::text_size::TextRange> {
         if let Some(value) = node.returns {
             self.visit_expr(*value);
         }
+        for value in node.type_params {
+            self.visit_type_param(value);
+        }
     }
     fn visit_stmt_async_function_def(&mut self, node: StmtAsyncFunctionDef<R>) {
         self.generic_visit_stmt_async_function_def(node)
@@ -71,6 +75,9 @@ pub trait Visitor<R = crate::text_size::TextRange> {
         if let Some(value) = node.returns {
             self.visit_expr(*value);
         }
+        for value in node.type_params {
+            self.visit_type_param(value);
+        }
     }
     fn visit_stmt_class_def(&mut self, node: StmtClassDef<R>) {
         self.generic_visit_stmt_class_def(node)
@@ -88,6 +95,9 @@ pub trait Visitor<R = crate::text_size::TextRange> {
         for value in node.decorator_list {
             self.visit_expr(value);
         }
+        for value in node.type_params {
+            self.visit_type_param(value);
+        }
     }
     fn visit_stmt_return(&mut self, node: StmtReturn<R>) {
         self.generic_visit_stmt_return(node)
@@ -117,6 +127,22 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_expr(*value);
         }
     }
+    fn visit_stmt_type_alias(&mut self, node: StmtTypeAlias<R>) {
+        self.generic_visit_stmt_type_alias(node)
+    }
+    fn generic_visit_stmt_type_alias(&mut self, node: StmtTypeAlias<R>) {
+        {
+            let value = node.name;
+            self.visit_expr(*value);
+        }
+        for value in node.type_params {
+            self.visit_type_param(value);
+        }
+        {
+            let value = node.value;
+            self.visit_expr(*value);
+        }
+    }
     fn visit_stmt_aug_assign(&mut self, node: StmtAugAssign<R>) {
         self.generic_visit_stmt_aug_assign(node)
     }
@@ -810,4 +836,30 @@ pub trait Visitor<R = crate::text_size::TextRange> {
             self.visit_pattern(value);
         }
     }
+    fn visit_type_param(&mut self, node: TypeParam<R>) {
+        self.generic_visit_type_param(node)
+    }
+    fn generic_visit_type_param(&mut self, node: TypeParam<R>) {
+        match node {
+            TypeParam::TypeVar(data) => self.visit_type_param_type_var(data),
+            TypeParam::ParamSpec(data) => self.visit_type_param_param_spec(data),
+            TypeParam::TypeVarTuple(data) => self.visit_type_param_type_var_tuple(data),
+        }
+    }
+    fn visit_type_param_type_var(&mut self, node: TypeParamTypeVar<R>) {
+        self.generic_visit_type_param_type_var(node)
+    }
+    fn generic_visit_type_param_type_var(&mut self, node: TypeParamTypeVar<R>) {
+        if let Some(value) = node.bound {
+            self.visit_expr(*value);
+        }
+    }
+    fn visit_type_param_param_spec(&mut self, node: TypeParamParamSpec<R>) {
+        self.generic_visit_type_param_param_spec(node)
+    }
+    fn generic_visit_type_param_param_spec(&mut self, node: TypeParamParamSpec<R>) {}
+    fn visit_type_param_type_var_tuple(&mut self, node: TypeParamTypeVarTuple<R>) {
+        self.generic_visit_type_param_type_var_tuple(node)
+    }
+    fn generic_visit_type_param_type_var_tuple(&mut self, node: TypeParamTypeVarTuple<R>) {}
 }
diff --git a/parser/src/gen/parse.rs b/parser/src/gen/parse.rs
index 01856ac2..64822875 100644
--- a/parser/src/gen/parse.rs
+++ b/parser/src/gen/parse.rs
@@ -138,6 +138,29 @@ impl Parse for ast::StmtAssign {
     }
 }
 
+impl Parse for ast::StmtTypeAlias {
+    fn lex_starts_at(
+        source: &str,
+        offset: TextSize,
+    ) -> SoftKeywordTransformer<Lexer<std::str::Chars>> {
+        ast::Stmt::lex_starts_at(source, offset)
+    }
+    fn parse_tokens(
+        lxr: impl IntoIterator<Item = LexResult>,
+        source_path: &str,
+    ) -> Result<Self, ParseError> {
+        let node = ast::Stmt::parse_tokens(lxr, source_path)?;
+        match node {
+            ast::Stmt::TypeAlias(node) => Ok(node),
+            node => Err(ParseError {
+                error: ParseErrorType::InvalidToken,
+                offset: node.range().start(),
+                source_path: source_path.to_owned(),
+            }),
+        }
+    }
+}
+
 impl Parse for ast::StmtAugAssign {
     fn lex_starts_at(
         source: &str,
diff --git a/parser/src/python.rs b/parser/src/python.rs
index a0b29e80..4a883e4b 100644
--- a/parser/src/python.rs
+++ b/parser/src/python.rs
@@ -1,20 +1,21 @@
 // auto-generated: "lalrpop 0.20.0"
 // sha3: c39f9711066c6f94aaf93d62d86b41efb4242ddcdcbe5b9d35e5a77a14ff22d6
 use crate::{
-    ast::{self as ast, Ranged, bigint::BigInt},
-    lexer::{LexicalError, LexicalErrorType},
-    function::{ArgumentList, parse_args, validate_pos_params, validate_arguments},
+    ast::{self as ast, bigint::BigInt, Ranged},
     context::set_context,
+    function::{parse_args, validate_arguments, validate_pos_params, ArgumentList},
+    lexer::{LexicalError, LexicalErrorType},
+    parser::optional_range,
     string::parse_strings,
+    text_size::TextSize,
     token::{self, StringKind},
-    text_size::TextSize, parser::optional_range
 };
 #[allow(unused_extern_crates)]
 extern crate lalrpop_util as __lalrpop_util;
 #[allow(unused_imports)]
 use self::__lalrpop_util::state_machine as __state_machine;
-extern crate core;
 extern crate alloc;
+extern crate core;
 
 #[rustfmt::skip]
 #[allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports, unused_parens, clippy::all)]
@@ -28709,68 +28710,64 @@ mod __parse__Top {
 pub use self::__parse__Top::TopParser;
 
 #[allow(clippy::too_many_arguments)]
-fn __action0<
->(
-    (_, __0, _): (TextSize, ast::Mod, TextSize),
-) -> ast::Mod
-{
+fn __action0((_, __0, _): (TextSize, ast::Mod, TextSize)) -> ast::Mod {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1<
->(
+fn __action1(
     (_, start, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
     (_, end, _): (TextSize, TextSize, TextSize),
-) -> ast::Mod
-{
-    ast::ModModule { body, type_ignores: vec![], range: optional_range(start, end) }.into()
+) -> ast::Mod {
+    ast::ModModule {
+        body,
+        type_ignores: vec![],
+        range: optional_range(start, end),
+    }
+    .into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action2<
->(
+fn __action2(
     (_, start, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
     (_, end, _): (TextSize, TextSize, TextSize),
-) -> ast::Mod
-{
-    ast::ModInteractive { body, range: optional_range(start, end) }.into()
+) -> ast::Mod {
+    ast::ModInteractive {
+        body,
+        range: optional_range(start, end),
+    }
+    .into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action3<
->(
+fn __action3(
     (_, start, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, alloc::vec::Vec<token::Tok>, TextSize),
     (_, end, _): (TextSize, TextSize, TextSize),
-) -> ast::Mod
-{
-    ast::ModExpression { body: Box::new(body), range: optional_range(start, end) }.into()
+) -> ast::Mod {
+    ast::ModExpression {
+        body: Box::new(body),
+        range: optional_range(start, end),
+    }
+    .into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action4<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> ast::Suite
-{
+fn __action4(__lookbehind: &TextSize, __lookahead: &TextSize) -> ast::Suite {
     vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action5<
->(
+fn __action5(
     (_, mut statements, _): (TextSize, ast::Suite, TextSize),
     (_, next, _): (TextSize, ast::Stmt, TextSize),
-) -> ast::Suite
-{
+) -> ast::Suite {
     {
         statements.push(next);
         statements
@@ -28778,15 +28775,13 @@ fn __action5<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action6<
->(
+fn __action6(
     (_, mut statements, _): (TextSize, ast::Suite, TextSize),
     (_, small, _): (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     (_, last, _): (TextSize, ast::Stmt, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Suite
-{
+) -> ast::Suite {
     {
         statements.extend(small);
         statements.push(last);
@@ -28795,24 +28790,20 @@ fn __action6<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action7<
->(
+fn __action7(
     (_, s, _): (TextSize, ast::Suite, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Suite
-{
+) -> ast::Suite {
     s
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action8<
->(
+fn __action8(
     (_, mut statements, _): (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     (_, last, _): (TextSize, ast::Stmt, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Suite
-{
+) -> ast::Suite {
     {
         statements.push(last);
         statements
@@ -28820,26 +28811,22 @@ fn __action8<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action9<
->(
+fn __action9(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, s, _): (TextSize, Vec<ast::Stmt>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Suite
-{
+) -> ast::Suite {
     s
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action10<
->(
+fn __action10(
     (_, mut head, _): (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     (_, last, _): (TextSize, ast::Stmt, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt>
-{
+) -> Vec<ast::Stmt> {
     {
         head.push(last);
         head
@@ -28847,21 +28834,15 @@ fn __action10<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action11<
->(
-    (_, s, _): (TextSize, ast::Stmt, TextSize),
-) -> Vec<ast::Stmt>
-{
+fn __action11((_, s, _): (TextSize, ast::Stmt, TextSize)) -> Vec<ast::Stmt> {
     vec![s]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action12<
->(
+fn __action12(
     (_, mut statements, _): (TextSize, Vec<ast::Stmt>, TextSize),
     (_, next, _): (TextSize, ast::Stmt, TextSize),
-) -> Vec<ast::Stmt>
-{
+) -> Vec<ast::Stmt> {
     {
         statements.push(next);
         statements
@@ -28869,15 +28850,13 @@ fn __action12<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action13<
->(
+fn __action13(
     (_, mut statements, _): (TextSize, Vec<ast::Stmt>, TextSize),
     (_, small, _): (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     (_, last, _): (TextSize, ast::Stmt, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt>
-{
+) -> Vec<ast::Stmt> {
     {
         statements.extend(small);
         statements.push(last);
@@ -28886,121 +28865,90 @@ fn __action13<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action14<
->(
-    (_, __0, _): (TextSize, ast::Stmt, TextSize),
-) -> ast::Stmt
-{
+fn __action14((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action15<
->(
-    (_, __0, _): (TextSize, ast::Stmt, TextSize),
-) -> ast::Stmt
-{
+fn __action15((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action16<
->(
-    (_, __0, _): (TextSize, ast::Stmt, TextSize),
-) -> ast::Stmt
-{
+fn __action16((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action17<
->(
-    (_, __0, _): (TextSize, ast::Stmt, TextSize),
-) -> ast::Stmt
-{
+fn __action17((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action18<
->(
-    (_, __0, _): (TextSize, ast::Stmt, TextSize),
-) -> ast::Stmt
-{
+fn __action18((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action19<
->(
-    (_, __0, _): (TextSize, ast::Stmt, TextSize),
-) -> ast::Stmt
-{
+fn __action19((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action20<
->(
-    (_, __0, _): (TextSize, ast::Stmt, TextSize),
-) -> ast::Stmt
-{
+fn __action20((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action21<
->(
-    (_, __0, _): (TextSize, ast::Stmt, TextSize),
-) -> ast::Stmt
-{
+fn __action21((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action22<
->(
+fn __action22(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
-        ast::Stmt::Pass(ast::StmtPass { range: (location..end_location).into() })
+        ast::Stmt::Pass(ast::StmtPass {
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action23<
->(
+fn __action23(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, targets, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
-    {
-        ast::Stmt::Delete(
-            ast::StmtDelete { targets: targets.into_iter().map(|expr| set_context(expr, ast::ExprContext::Del)).collect(), range: (location..end_location).into()  }
-        )
+) -> ast::Stmt {
+    {
+        ast::Stmt::Delete(ast::StmtDelete {
+            targets: targets
+                .into_iter()
+                .map(|expr| set_context(expr, ast::ExprContext::Del))
+                .collect(),
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action24<
->(
+fn __action24(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, expression, _): (TextSize, ast::Expr, TextSize),
     (_, suffix, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
         // Just an expression, no assignment:
         if suffix.is_empty() {
-            ast::Stmt::Expr(
-                ast::StmtExpr { value: Box::new(expression), range: (location..end_location).into() }
-            )
+            ast::Stmt::Expr(ast::StmtExpr {
+                value: Box::new(expression),
+                range: (location..end_location).into(),
+            })
         } else {
             let mut targets = vec![set_context(expression, ast::ExprContext::Store)];
             let mut values = suffix;
@@ -29011,503 +28959,390 @@ fn __action24<
                 targets.push(set_context(target, ast::ExprContext::Store));
             }
 
-            ast::Stmt::Assign(
-                ast::StmtAssign { targets, value, type_comment: None, range: (location..end_location).into() }
-            )
+            ast::Stmt::Assign(ast::StmtAssign {
+                targets,
+                value,
+                type_comment: None,
+                range: (location..end_location).into(),
+            })
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action25<
->(
+fn __action25(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, target, _): (TextSize, ast::Expr, TextSize),
     (_, op, _): (TextSize, ast::Operator, TextSize),
     (_, rhs, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
-    {
-        ast::Stmt::AugAssign(
-            ast::StmtAugAssign {
-                target: Box::new(set_context(target, ast::ExprContext::Store)),
-                op,
-                value: Box::new(rhs),
-                range: (location..end_location).into()
-            },
-        )
+) -> ast::Stmt {
+    {
+        ast::Stmt::AugAssign(ast::StmtAugAssign {
+            target: Box::new(set_context(target, ast::ExprContext::Store)),
+            op,
+            value: Box::new(rhs),
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action26<
->(
+fn __action26(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, target, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, annotation, _): (TextSize, ast::Expr, TextSize),
     (_, rhs, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
         let simple = target.is_name_expr();
-        ast::Stmt::AnnAssign(
-            ast::StmtAnnAssign {
-                target: Box::new(set_context(target, ast::ExprContext::Store)),
-                annotation: Box::new(annotation),
-                value: rhs.map(Box::new),
-                simple,
-                range: (location..end_location).into()
-            },
-        )
+        ast::Stmt::AnnAssign(ast::StmtAnnAssign {
+            target: Box::new(set_context(target, ast::ExprContext::Store)),
+            annotation: Box::new(annotation),
+            value: rhs.map(Box::new),
+            simple,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action27<
->(
+fn __action27(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     e
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action28<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action28((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action29<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action29((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action30<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action30((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action31<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action31((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action32<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action32((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action33<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action33((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action34<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action34((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action35<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action35((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action36<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action36((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action37<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Operator
-{
+fn __action37((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
     ast::Operator::Add
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action38<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Operator
-{
+fn __action38((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
     ast::Operator::Sub
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action39<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Operator
-{
+fn __action39((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
     ast::Operator::Mult
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action40<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Operator
-{
+fn __action40((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
     ast::Operator::MatMult
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action41<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Operator
-{
+fn __action41((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
     ast::Operator::Div
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action42<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Operator
-{
+fn __action42((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
     ast::Operator::Mod
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action43<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Operator
-{
+fn __action43((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
     ast::Operator::BitAnd
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action44<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Operator
-{
+fn __action44((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
     ast::Operator::BitOr
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action45<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Operator
-{
+fn __action45((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
     ast::Operator::BitXor
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action46<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Operator
-{
+fn __action46((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
     ast::Operator::LShift
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action47<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Operator
-{
+fn __action47((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
     ast::Operator::RShift
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action48<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Operator
-{
+fn __action48((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
     ast::Operator::Pow
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action49<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Operator
-{
+fn __action49((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
     ast::Operator::FloorDiv
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action50<
->(
+fn __action50(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
-
-        ast::Stmt::Break(ast::StmtBreak { range: (location..end_location).into() })
+        ast::Stmt::Break(ast::StmtBreak {
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action51<
->(
+fn __action51(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
-        ast::Stmt::Continue(ast::StmtContinue { range: (location..end_location).into() })
+        ast::Stmt::Continue(ast::StmtContinue {
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action52<
->(
+fn __action52(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, value, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
-        ast::Stmt::Return(
-            ast::StmtReturn { value: value.map(Box::new), range: (location..end_location).into() }
-        )
+        ast::Stmt::Return(ast::StmtReturn {
+            value: value.map(Box::new),
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action53<
->(
+fn __action53(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, expression, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
-        ast::Stmt::Expr(
-            ast::StmtExpr { value: Box::new(expression), range: (location..end_location).into() }
-        )
+        ast::Stmt::Expr(ast::StmtExpr {
+            value: Box::new(expression),
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action54<
->(
-    (_, __0, _): (TextSize, ast::Stmt, TextSize),
-) -> ast::Stmt
-{
+fn __action54((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action55<
->(
+fn __action55(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
-        ast::Stmt::Raise(
-            ast::StmtRaise { exc: None, cause: None, range: (location..end_location).into() }
-        )
+        ast::Stmt::Raise(ast::StmtRaise {
+            exc: None,
+            cause: None,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action56<
->(
+fn __action56(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, t, _): (TextSize, ast::Expr, TextSize),
     (_, c, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
-        ast::Stmt::Raise(
-            ast::StmtRaise { exc: Some(Box::new(t)), cause: c.map(|x| Box::new(x)), range: (location..end_location).into() }
-        )
+        ast::Stmt::Raise(ast::StmtRaise {
+            exc: Some(Box::new(t)),
+            cause: c.map(|x| Box::new(x)),
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action57<
->(
+fn __action57(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, names, _): (TextSize, Vec<ast::Alias>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
-        ast::Stmt::Import(
-            ast::StmtImport { names, range: (location..end_location).into() }
-        )
+        ast::Stmt::Import(ast::StmtImport {
+            names,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action58<
->(
+fn __action58(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-    (_, source, _): (TextSize, (Option<ast::Int>, Option<ast::Identifier>), TextSize),
+    (_, source, _): (
+        TextSize,
+        (Option<ast::Int>, Option<ast::Identifier>),
+        TextSize,
+    ),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, names, _): (TextSize, Vec<ast::Alias>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
         let (level, module) = source;
-        ast::Stmt::ImportFrom(
-            ast::StmtImportFrom {
-                level,
-                module,
-                names,
-                range: (location..end_location).into()
-            },
-        )
+        ast::Stmt::ImportFrom(ast::StmtImportFrom {
+            level,
+            module,
+            names,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action59<
->(
+fn __action59(
     (_, dots, _): (TextSize, alloc::vec::Vec<ast::Int>, TextSize),
     (_, name, _): (TextSize, ast::Identifier, TextSize),
-) -> (Option<ast::Int>, Option<ast::Identifier>)
-{
+) -> (Option<ast::Int>, Option<ast::Identifier>) {
     {
-        (Some(ast::Int::new(dots.iter().map(ast::Int::to_u32).sum())), Some(name))
+        (
+            Some(ast::Int::new(dots.iter().map(ast::Int::to_u32).sum())),
+            Some(name),
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action60<
->(
+fn __action60(
     (_, dots, _): (TextSize, alloc::vec::Vec<ast::Int>, TextSize),
-) -> (Option<ast::Int>, Option<ast::Identifier>)
-{
+) -> (Option<ast::Int>, Option<ast::Identifier>) {
     {
-        (Some(ast::Int::new(dots.iter().map(ast::Int::to_u32).sum())), None)
+        (
+            Some(ast::Int::new(dots.iter().map(ast::Int::to_u32).sum())),
+            None,
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action61<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Int
-{
+fn __action61((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Int {
     ast::Int::new(3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action62<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Int
-{
+fn __action62((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Int {
     ast::Int::new(1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action63<
->(
+fn __action63(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, i, _): (TextSize, Vec<ast::Alias>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Vec<ast::Alias>
-{
+) -> Vec<ast::Alias> {
     i
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action64<
->(
+fn __action64(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, i, _): (TextSize, Vec<ast::Alias>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Vec<ast::Alias>
-{
+) -> Vec<ast::Alias> {
     i
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action65<
->(
+fn __action65(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Vec<ast::Alias>
-{
+) -> Vec<ast::Alias> {
     {
         // Star import all
-        vec![ast::Alias { name: ast::Identifier::new("*"), asname: None, range: (location..end_location).into() }]
+        vec![ast::Alias {
+            name: ast::Identifier::new("*"),
+            asname: None,
+            range: (location..end_location).into(),
+        }]
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action66<
->(
-    (_, n, _): (TextSize, String, TextSize),
-) -> ast::Identifier
-{
+fn __action66((_, n, _): (TextSize, String, TextSize)) -> ast::Identifier {
     ast::Identifier::new(n)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action67<
->(
+fn __action67(
     (_, n, _): (TextSize, String, TextSize),
-    (_, n2, _): (TextSize, alloc::vec::Vec<(token::Tok, ast::Identifier)>, TextSize),
-) -> ast::Identifier
-{
+    (_, n2, _): (
+        TextSize,
+        alloc::vec::Vec<(token::Tok, ast::Identifier)>,
+        TextSize,
+    ),
+) -> ast::Identifier {
     {
         let mut r = n.to_string();
         for x in n2 {
@@ -29519,133 +29354,94 @@ fn __action67<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action68<
->(
+fn __action68(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, names, _): (TextSize, Vec<ast::Identifier>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
-        ast::Stmt::Global(
-            ast::StmtGlobal { names, range: (location..end_location).into() }
-        )
+        ast::Stmt::Global(ast::StmtGlobal {
+            names,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action69<
->(
+fn __action69(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, names, _): (TextSize, Vec<ast::Identifier>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
-        ast::Stmt::Nonlocal(
-            ast::StmtNonlocal { names, range: (location..end_location).into() }
-        )
+        ast::Stmt::Nonlocal(ast::StmtNonlocal {
+            names,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action70<
->(
+fn __action70(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, test, _): (TextSize, ast::Expr, TextSize),
     (_, msg, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
-        ast::Stmt::Assert(
-            ast::StmtAssert {
-                test: Box::new(test),
-                msg: msg.map(|e| Box::new(e)),
-                range: (location..end_location).into()
-            }
-        )
+        ast::Stmt::Assert(ast::StmtAssert {
+            test: Box::new(test),
+            msg: msg.map(|e| Box::new(e)),
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action71<
->(
-    (_, __0, _): (TextSize, ast::Stmt, TextSize),
-) -> ast::Stmt
-{
+fn __action71((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action72<
->(
-    (_, __0, _): (TextSize, ast::Stmt, TextSize),
-) -> ast::Stmt
-{
+fn __action72((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action73<
->(
-    (_, __0, _): (TextSize, ast::Stmt, TextSize),
-) -> ast::Stmt
-{
+fn __action73((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action74<
->(
-    (_, __0, _): (TextSize, ast::Stmt, TextSize),
-) -> ast::Stmt
-{
+fn __action74((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action75<
->(
-    (_, __0, _): (TextSize, ast::Stmt, TextSize),
-) -> ast::Stmt
-{
+fn __action75((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action76<
->(
-    (_, __0, _): (TextSize, ast::Stmt, TextSize),
-) -> ast::Stmt
-{
+fn __action76((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action77<
->(
-    (_, __0, _): (TextSize, ast::Stmt, TextSize),
-) -> ast::Stmt
-{
+fn __action77((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action78<
->(
-    (_, __0, _): (TextSize, ast::Stmt, TextSize),
-) -> ast::Stmt
-{
+fn __action78((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action79<
->(
+fn __action79(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, subject, _): (TextSize, ast::Expr, TextSize),
@@ -29654,29 +29450,19 @@ fn __action79<
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, cases, _): (TextSize, alloc::vec::Vec<ast::MatchCase>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
-       let end_location = cases
-            .last()
-            .unwrap()
-            .body
-            .last()
-            .unwrap()
-            .end();
-        ast::Stmt::Match(
-            ast::StmtMatch {
-                subject: Box::new(subject),
-                cases,
-                range: (location..end_location).into()
-            }
-        )
+        let end_location = cases.last().unwrap().body.last().unwrap().end();
+        ast::Stmt::Match(ast::StmtMatch {
+            subject: Box::new(subject),
+            cases,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action80<
->(
+fn __action80(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, subject, _): (TextSize, ast::Expr, TextSize),
@@ -29686,29 +29472,19 @@ fn __action80<
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, cases, _): (TextSize, alloc::vec::Vec<ast::MatchCase>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
-       let end_location = cases
-            .last()
-            .unwrap()
-            .body
-            .last()
-            .unwrap()
-            .end();
-        ast::Stmt::Match(
-            ast::StmtMatch {
-                subject: Box::new(subject),
-                cases,
-                range: (location..end_location).into()
-            }
-        )
+        let end_location = cases.last().unwrap().body.last().unwrap().end();
+        ast::Stmt::Match(ast::StmtMatch {
+            subject: Box::new(subject),
+            cases,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action81<
->(
+fn __action81(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, subjects, _): (TextSize, Vec<ast::Expr>, TextSize),
@@ -29718,43 +29494,30 @@ fn __action81<
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, cases, _): (TextSize, alloc::vec::Vec<ast::MatchCase>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Stmt
-{
-    {
-        let end_location = cases
-            .last()
-            .unwrap()
-            .body
-            .last()
-            .unwrap()
-            .end();
-        ast::Stmt::Match(
-            ast::StmtMatch {
-                subject: Box::new(ast::Expr::Tuple(
-                    ast::ExprTuple {
-                        elts: subjects,
-                        ctx: ast::ExprContext::Load,
-                        range: (location..end_location).into()
-                    },
-                )),
-                cases,
-                range: (location..end_location).into()
-            }
-        )
+) -> ast::Stmt {
+    {
+        let end_location = cases.last().unwrap().body.last().unwrap().end();
+        ast::Stmt::Match(ast::StmtMatch {
+            subject: Box::new(ast::Expr::Tuple(ast::ExprTuple {
+                elts: subjects,
+                ctx: ast::ExprContext::Load,
+                range: (location..end_location).into(),
+            })),
+            cases,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action82<
->(
+fn __action82(
     (_, start, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, pattern, _): (TextSize, ast::Pattern, TextSize),
     (_, guard, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
-) -> ast::MatchCase
-{
+) -> ast::MatchCase {
     {
         // SAFETY: `body` is never empty because it is non-optional and `Suite` matches one or more statements.
         let end = body.last().unwrap().end();
@@ -29762,96 +29525,72 @@ fn __action82<
             pattern,
             guard: guard.map(Box::new),
             body,
-            range: optional_range(start, end)
+            range: optional_range(start, end),
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action83<
->(
+fn __action83(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, guard, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
         guard
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action84<
->(
+fn __action84(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, pattern, _): (TextSize, ast::Pattern, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
-    ast::Pattern::MatchSequence(
-        ast::PatternMatchSequence {
-            patterns: vec![pattern],
-            range: (location..end_location).into()
-        },
-    )
+) -> ast::Pattern {
+    ast::Pattern::MatchSequence(ast::PatternMatchSequence {
+        patterns: vec![pattern],
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action85<
->(
+fn __action85(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, patterns, _): (TextSize, Vec<ast::Pattern>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     {
-        ast::Pattern::MatchSequence(
-            ast::PatternMatchSequence {
-                patterns,
-                range: (location..end_location).into()
-            },
-        )
+        ast::Pattern::MatchSequence(ast::PatternMatchSequence {
+            patterns,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action86<
->(
-    (_, pattern, _): (TextSize, ast::Pattern, TextSize),
-) -> ast::Pattern
-{
+fn __action86((_, pattern, _): (TextSize, ast::Pattern, TextSize)) -> ast::Pattern {
     pattern
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action87<
->(
-    (_, pattern, _): (TextSize, ast::Pattern, TextSize),
-) -> ast::Pattern
-{
+fn __action87((_, pattern, _): (TextSize, ast::Pattern, TextSize)) -> ast::Pattern {
     pattern
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action88<
->(
-    (_, pattern, _): (TextSize, ast::Pattern, TextSize),
-) -> ast::Pattern
-{
+fn __action88((_, pattern, _): (TextSize, ast::Pattern, TextSize)) -> ast::Pattern {
     pattern
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action89<
->(
+fn __action89(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, pattern, _): (TextSize, ast::Pattern, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, name, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Pattern,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Pattern, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     {
         if name.as_str() == "_" {
             Err(LexicalError {
@@ -29859,154 +29598,114 @@ fn __action89<
                 location,
             })?
         } else {
-            Ok(ast::Pattern::MatchAs(
-                ast::PatternMatchAs {
-                   pattern: Some(Box::new(pattern)),
-                   name: Some(name),
-                   range: (location..end_location).into()
-                },
-            ))
+            Ok(ast::Pattern::MatchAs(ast::PatternMatchAs {
+                pattern: Some(Box::new(pattern)),
+                name: Some(name),
+                range: (location..end_location).into(),
+            }))
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action90<
->(
-    (_, pattern, _): (TextSize, ast::Pattern, TextSize),
-) -> ast::Pattern
-{
+fn __action90((_, pattern, _): (TextSize, ast::Pattern, TextSize)) -> ast::Pattern {
     pattern
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action91<
->(
+fn __action91(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, patterns, _): (TextSize, Vec<ast::Pattern>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     {
-        ast::Pattern::MatchOr(
-            ast::PatternMatchOr { patterns, range: (location..end_location).into() }
-        )
+        ast::Pattern::MatchOr(ast::PatternMatchOr {
+            patterns,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action92<
->(
-    (_, node, _): (TextSize, ast::Pattern, TextSize),
-) -> ast::Pattern
-{
+fn __action92((_, node, _): (TextSize, ast::Pattern, TextSize)) -> ast::Pattern {
     node
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action93<
->(
-    (_, node, _): (TextSize, ast::Pattern, TextSize),
-) -> ast::Pattern
-{
+fn __action93((_, node, _): (TextSize, ast::Pattern, TextSize)) -> ast::Pattern {
     node
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action94<
->(
-    (_, node, _): (TextSize, ast::Pattern, TextSize),
-) -> ast::Pattern
-{
+fn __action94((_, node, _): (TextSize, ast::Pattern, TextSize)) -> ast::Pattern {
     node
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action95<
->(
-    (_, node, _): (TextSize, ast::Pattern, TextSize),
-) -> ast::Pattern
-{
+fn __action95((_, node, _): (TextSize, ast::Pattern, TextSize)) -> ast::Pattern {
     node
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action96<
->(
-    (_, node, _): (TextSize, ast::Pattern, TextSize),
-) -> ast::Pattern
-{
+fn __action96((_, node, _): (TextSize, ast::Pattern, TextSize)) -> ast::Pattern {
     node
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action97<
->(
-    (_, node, _): (TextSize, ast::Pattern, TextSize),
-) -> ast::Pattern
-{
+fn __action97((_, node, _): (TextSize, ast::Pattern, TextSize)) -> ast::Pattern {
     node
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action98<
->(
-    (_, node, _): (TextSize, ast::Pattern, TextSize),
-) -> ast::Pattern
-{
+fn __action98((_, node, _): (TextSize, ast::Pattern, TextSize)) -> ast::Pattern {
     node
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action99<
->(
+fn __action99(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, pattern, _): (TextSize, ast::Pattern, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     pattern
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action100<
->(
+fn __action100(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     ast::PatternMatchSequence {
         patterns: vec![],
-        range: (location..end_location).into()
-    }.into()
+        range: (location..end_location).into(),
+    }
+    .into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action101<
->(
+fn __action101(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, pattern, _): (TextSize, ast::Pattern, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     {
-            ast::PatternMatchSequence {
-                patterns: vec![pattern],
-                range: (location..end_location).into()
-            }.into()
+        ast::PatternMatchSequence {
+            patterns: vec![pattern],
+            range: (location..end_location).into(),
         }
+        .into()
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action102<
->(
+fn __action102(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, patterns, _): (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
@@ -30014,420 +29713,373 @@ fn __action102<
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     {
         let mut patterns = patterns;
         patterns.push(last);
         ast::PatternMatchSequence {
             patterns,
-            range: (location..end_location).into()
-        }.into()
+            range: (location..end_location).into(),
+        }
+        .into()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action103<
->(
+fn __action103(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, patterns, _): (TextSize, Vec<ast::Pattern>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     ast::PatternMatchSequence {
         patterns,
-        range: (location..end_location).into()
-    }.into()
+        range: (location..end_location).into(),
+    }
+    .into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action104<
->(
+fn __action104(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, name, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     ast::PatternMatchStar {
-        name: if name.as_str() == "_" { None } else { Some(name) },
-        range: (location..end_location).into()
-    }.into()
+        name: if name.as_str() == "_" {
+            None
+        } else {
+            Some(name)
+        },
+        range: (location..end_location).into(),
+    }
+    .into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action105<
->(
+fn __action105(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, value, _): (TextSize, ast::Constant, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Constant(
-        ast::ExprConstant { value, kind: None, range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::Constant(ast::ExprConstant {
+        value,
+        kind: None,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action106<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action106((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action107<
->(
+fn __action107(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, operand, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::UnaryOp(
-        ast::ExprUnaryOp {
-            op: ast::UnaryOp::USub,
-            operand: Box::new(operand),
-            range: (location..end_location).into()
-        }
-    )
+) -> ast::Expr {
+    ast::Expr::UnaryOp(ast::ExprUnaryOp {
+        op: ast::UnaryOp::USub,
+        operand: Box::new(operand),
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action108<
->(
+fn __action108(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, left, _): (TextSize, ast::Expr, TextSize),
     (_, op, _): (TextSize, ast::Operator, TextSize),
     (_, right, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::BinOp(
-        ast::ExprBinOp {
-            left: Box::new(left),
-            op,
-            right: Box::new(right),
-            range: (location..end_location).into()
-        }
-    )
+) -> ast::Expr {
+    ast::Expr::BinOp(ast::ExprBinOp {
+        left: Box::new(left),
+        op,
+        right: Box::new(right),
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action109<
->(
+fn __action109(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     ast::PatternMatchSingleton {
         value: ast::Constant::None,
-        range: (location..end_location).into()
-    }.into()
+        range: (location..end_location).into(),
+    }
+    .into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action110<
->(
+fn __action110(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     ast::PatternMatchSingleton {
         value: true.into(),
-        range: (location..end_location).into()
-    }.into()
+        range: (location..end_location).into(),
+    }
+    .into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action111<
->(
+fn __action111(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     ast::PatternMatchSingleton {
         value: false.into(),
-        range: (location..end_location).into()
-    }.into()
+        range: (location..end_location).into(),
+    }
+    .into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action112<
->(
+fn __action112(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, value, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     ast::PatternMatchValue {
         value: Box::new(value),
-        range: (location..end_location).into()
-    }.into()
+        range: (location..end_location).into(),
+    }
+    .into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action113<
->(
+fn __action113(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, value, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     ast::PatternMatchValue {
         value: Box::new(value),
-        range: (location..end_location).into()
-    }.into()
+        range: (location..end_location).into(),
+    }
+    .into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action114<
->(
+fn __action114(
     (_, location, _): (TextSize, TextSize, TextSize),
-    (_, s, _): (TextSize, alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>, TextSize),
+    (_, s, _): (
+        TextSize,
+        alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>,
+        TextSize,
+    ),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Pattern,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Pattern, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     Ok(ast::PatternMatchValue {
         value: Box::new(parse_strings(s)?),
-        range: (location..end_location).into()
-    }.into())
+        range: (location..end_location).into(),
+    }
+    .into())
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action115<
->(
+fn __action115(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, name, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     ast::PatternMatchAs {
         pattern: None,
-        name: if name.as_str() == "_" { None } else { Some(name) },
-        range: (location..end_location).into()
-    }.into()
+        name: if name.as_str() == "_" {
+            None
+        } else {
+            Some(name)
+        },
+        range: (location..end_location).into(),
+    }
+    .into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action116<
->(
+fn __action116(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, name, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Name(
-        ast::ExprName { id: name, ctx: ast::ExprContext::Load, range: (location..end_location).into() },
-    )
+) -> ast::Expr {
+    ast::Expr::Name(ast::ExprName {
+        id: name,
+        ctx: ast::ExprContext::Load,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action117<
->(
+fn __action117(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, name, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, attr, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Attribute(
-        ast::ExprAttribute {
-            value: Box::new(name),
-            attr,
-            ctx: ast::ExprContext::Load,
-            range: (location..end_location).into()
-        },
-    )
+) -> ast::Expr {
+    ast::Expr::Attribute(ast::ExprAttribute {
+        value: Box::new(name),
+        attr,
+        ctx: ast::ExprContext::Load,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action118<
->(
+fn __action118(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, attr, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Attribute(
-        ast::ExprAttribute {
-            value: Box::new(e),
-            attr,
-            ctx: ast::ExprContext::Load,
-            range: (location..end_location).into()
-        },
-    )
+) -> ast::Expr {
+    ast::Expr::Attribute(ast::ExprAttribute {
+        value: Box::new(e),
+        attr,
+        ctx: ast::ExprContext::Load,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action119<
->(
+fn __action119(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     ast::PatternMatchValue {
-       value: Box::new(e),
-       range: (location..end_location).into()
-   }.into()
+        value: Box::new(e),
+        range: (location..end_location).into(),
+    }
+    .into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action120<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action120((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action121<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action121((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action122<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action122((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action123<
->(
+fn __action123(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Constant(
-        ast::ExprConstant {
-            value: ast::Constant::None,
-            kind: None,
-            range: (location..end_location).into()
-        },
-    )
+) -> ast::Expr {
+    ast::Expr::Constant(ast::ExprConstant {
+        value: ast::Constant::None,
+        kind: None,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action124<
->(
+fn __action124(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Constant(
-        ast::ExprConstant {
-            value: true.into(),
-            kind: None,
-            range: (location..end_location).into()
-        },
-    )
+) -> ast::Expr {
+    ast::Expr::Constant(ast::ExprConstant {
+        value: true.into(),
+        kind: None,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action125<
->(
+fn __action125(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Constant(
-        ast::ExprConstant {
-            value: false.into(),
-            kind: None,
-            range: (location..end_location).into()
-        },
-    )
+) -> ast::Expr {
+    ast::Expr::Constant(ast::ExprConstant {
+        value: false.into(),
+        kind: None,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action126<
->(
+fn __action126(
     (_, location, _): (TextSize, TextSize, TextSize),
-    (_, s, _): (TextSize, alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+    (_, s, _): (
+        TextSize,
+        alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>,
+        TextSize,
+    ),
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     Ok(parse_strings(s)?)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action127<
->(
+fn __action127(
     (_, k, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, v, _): (TextSize, ast::Pattern, TextSize),
-) -> (ast::Expr, ast::Pattern)
-{
+) -> (ast::Expr, ast::Pattern) {
     (k, v)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action128<
->(
+fn __action128(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     {
         return ast::PatternMatchMapping {
             keys: vec![],
             patterns: vec![],
             rest: None,
-            range: (location..end_location).into()
-        }.into();
+            range: (location..end_location).into(),
+        }
+        .into();
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action129<
->(
+fn __action129(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     {
-        let (keys, patterns) = e
-            .into_iter()
-            .unzip();
+        let (keys, patterns) = e.into_iter().unzip();
         return ast::PatternMatchMapping {
             keys,
             patterns,
             rest: None,
-            range: (location..end_location).into()
-        }.into();
+            range: (location..end_location).into(),
+        }
+        .into();
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action130<
->(
+fn __action130(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -30435,21 +30087,20 @@ fn __action130<
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     {
         return ast::PatternMatchMapping {
             keys: vec![],
             patterns: vec![],
             rest: Some(rest),
-            range: (location..end_location).into()
-        }.into();
+            range: (location..end_location).into(),
+        }
+        .into();
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action131<
->(
+fn __action131(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
@@ -30459,35 +30110,30 @@ fn __action131<
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     {
-        let (keys, patterns) = e
-            .into_iter()
-            .unzip();
+        let (keys, patterns) = e.into_iter().unzip();
         return ast::PatternMatchMapping {
             keys,
             patterns,
             rest: Some(rest),
-            range: (location..end_location).into()
-        }.into();
+            range: (location..end_location).into(),
+        }
+        .into();
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action132<
->(
+fn __action132(
     (_, k, _): (TextSize, ast::Identifier, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, v, _): (TextSize, ast::Pattern, TextSize),
-) -> (ast::Identifier, ast::Pattern)
-{
+) -> (ast::Identifier, ast::Pattern) {
     (k, v)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action133<
->(
+fn __action133(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -30497,25 +30143,22 @@ fn __action133<
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     {
-        let (kwd_attrs, kwd_patterns) = kwds
-            .into_iter()
-            .unzip();
+        let (kwd_attrs, kwd_patterns) = kwds.into_iter().unzip();
         ast::PatternMatchClass {
             cls: Box::new(e),
             patterns,
             kwd_attrs,
             kwd_patterns,
-            range: (location..end_location).into()
-        }.into()
+            range: (location..end_location).into(),
+        }
+        .into()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action134<
->(
+fn __action134(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -30523,22 +30166,21 @@ fn __action134<
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     {
         ast::PatternMatchClass {
             cls: Box::new(e),
             patterns,
             kwd_attrs: vec![],
             kwd_patterns: vec![],
-            range: (location..end_location).into()
-        }.into()
+            range: (location..end_location).into(),
+        }
+        .into()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action135<
->(
+fn __action135(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -30546,46 +30188,42 @@ fn __action135<
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     {
-         let (kwd_attrs, kwd_patterns) = kwds
-            .into_iter()
-            .unzip();
+        let (kwd_attrs, kwd_patterns) = kwds.into_iter().unzip();
         ast::PatternMatchClass {
             cls: Box::new(e),
             patterns: vec![],
             kwd_attrs,
             kwd_patterns,
-            range: (location..end_location).into()
-        }.into()
+            range: (location..end_location).into(),
+        }
+        .into()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action136<
->(
+fn __action136(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     {
         ast::PatternMatchClass {
             cls: Box::new(e),
             patterns: vec![],
             kwd_attrs: vec![],
             kwd_patterns: vec![],
-            range: (location..end_location).into()
-        }.into()
+            range: (location..end_location).into(),
+        }
+        .into()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action137<
->(
+fn __action137(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -30595,25 +30233,22 @@ fn __action137<
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     {
-        let (kwd_attrs, kwd_patterns) = kwds
-            .into_iter()
-            .unzip();
+        let (kwd_attrs, kwd_patterns) = kwds.into_iter().unzip();
         ast::PatternMatchClass {
             cls: Box::new(e),
             patterns,
             kwd_attrs,
             kwd_patterns,
-            range: (location..end_location).into()
-        }.into()
+            range: (location..end_location).into(),
+        }
+        .into()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action138<
->(
+fn __action138(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -30621,22 +30256,21 @@ fn __action138<
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     {
         ast::PatternMatchClass {
             cls: Box::new(e),
             patterns,
             kwd_attrs: vec![],
             kwd_patterns: vec![],
-            range: (location..end_location).into()
-        }.into()
+            range: (location..end_location).into(),
+        }
+        .into()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action139<
->(
+fn __action139(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -30644,55 +30278,54 @@ fn __action139<
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     {
-         let (kwd_attrs, kwd_patterns) = kwds
-            .into_iter()
-            .unzip();
+        let (kwd_attrs, kwd_patterns) = kwds.into_iter().unzip();
         ast::PatternMatchClass {
             cls: Box::new(e),
             patterns: vec![],
             kwd_attrs,
             kwd_patterns,
-            range: (location..end_location).into()
-        }.into()
+            range: (location..end_location).into(),
+        }
+        .into()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action140<
->(
+fn __action140(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     {
         ast::PatternMatchClass {
             cls: Box::new(e),
             patterns: vec![],
             kwd_attrs: vec![],
             kwd_patterns: vec![],
-            range: (location..end_location).into()
-        }.into()
+            range: (location..end_location).into(),
+        }
+        .into()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action141<
->(
+fn __action141(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, test, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
-    (_, s2, _): (TextSize, alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>, TextSize),
+    (_, s2, _): (
+        TextSize,
+        alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>,
+        TextSize,
+    ),
     (_, s3, _): (TextSize, core::option::Option<ast::Suite>, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
         // Determine last else:
         let mut last = s3.unwrap_or_default();
@@ -30704,50 +30337,47 @@ fn __action141<
             .end();
         // handle elif:
         for i in s2.into_iter().rev() {
-            let x = ast::Stmt::If(
-                ast::StmtIf { test: Box::new(i.1), body: i.2, orelse: last, range: (i.0..end_location).into() }
-            );
+            let x = ast::Stmt::If(ast::StmtIf {
+                test: Box::new(i.1),
+                body: i.2,
+                orelse: last,
+                range: (i.0..end_location).into(),
+            });
             last = vec![x];
         }
 
-        ast::Stmt::If(
-            ast::StmtIf { test: Box::new(test), body, orelse: last, range: (location..end_location).into() }
-        )
+        ast::Stmt::If(ast::StmtIf {
+            test: Box::new(test),
+            body,
+            orelse: last,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action142<
->(
+fn __action142(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, test, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
     (_, s2, _): (TextSize, core::option::Option<ast::Suite>, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
         let orelse = s2.unwrap_or_default();
-        let end_location = orelse
-            .last()
-            .or_else(|| body.last())
-            .unwrap()
-            .end();
-        ast::Stmt::While(
-            ast::StmtWhile {
-                test: Box::new(test),
-                body,
-                orelse,
-                range: (location..end_location).into()
-            },
-        )
+        let end_location = orelse.last().or_else(|| body.last()).unwrap().end();
+        ast::Stmt::While(ast::StmtWhile {
+            test: Box::new(test),
+            body,
+            orelse,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action143<
->(
+fn __action143(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, is_async, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -30757,29 +30387,37 @@ fn __action143<
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
     (_, orelse, _): (TextSize, core::option::Option<ast::Suite>, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
         let orelse = orelse.unwrap_or_default();
-        let end_location = orelse
-            .last()
-            .or_else(|| body.last())
-            .unwrap()
-            .end();
+        let end_location = orelse.last().or_else(|| body.last()).unwrap().end();
         let target = Box::new(set_context(target, ast::ExprContext::Store));
         let iter = Box::new(iter);
         let type_comment = None;
         if is_async.is_some() {
-            ast::Stmt::AsyncFor(ast::StmtAsyncFor { target, iter, body, orelse, type_comment, range: (location..end_location).into() })
+            ast::Stmt::AsyncFor(ast::StmtAsyncFor {
+                target,
+                iter,
+                body,
+                orelse,
+                type_comment,
+                range: (location..end_location).into(),
+            })
         } else {
-            ast::Stmt::For(ast::StmtFor { target, iter, body, orelse, type_comment, range: (location..end_location).into() })
+            ast::Stmt::For(ast::StmtFor {
+                target,
+                iter,
+                body,
+                orelse,
+                type_comment,
+                range: (location..end_location).into(),
+            })
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action144<
->(
+fn __action144(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -30788,8 +30426,7 @@ fn __action144<
     (_, orelse, _): (TextSize, core::option::Option<ast::Suite>, TextSize),
     (_, finalbody, _): (TextSize, core::option::Option<ast::Suite>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
         let orelse = orelse.unwrap_or_default();
         let finalbody = finalbody.unwrap_or_default();
@@ -30799,21 +30436,18 @@ fn __action144<
             .or_else(|| orelse.last().map(|last| last.end()))
             .or_else(|| handlers.last().map(|last| last.end()))
             .unwrap();
-        ast::Stmt::Try(
-            ast::StmtTry {
-                body,
-                handlers,
-                orelse,
-                finalbody,
-                range: (location..end_location).into()
-            },
-        )
+        ast::Stmt::Try(ast::StmtTry {
+            body,
+            handlers,
+            orelse,
+            finalbody,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action145<
->(
+fn __action145(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -30822,8 +30456,7 @@ fn __action145<
     (_, orelse, _): (TextSize, core::option::Option<ast::Suite>, TextSize),
     (_, finalbody, _): (TextSize, core::option::Option<ast::Suite>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
         let orelse = orelse.unwrap_or_default();
         let finalbody = finalbody.unwrap_or_default();
@@ -30833,225 +30466,210 @@ fn __action145<
             .map(|last| last.end())
             .or_else(|| handlers.last().map(|last| last.end()))
             .unwrap();
-        ast::Stmt::TryStar(
-            ast::StmtTryStar {
-                body,
-                handlers,
-                orelse,
-                finalbody,
-                range: (location..end_location).into()
-            },
-        )
+        ast::Stmt::TryStar(ast::StmtTryStar {
+            body,
+            handlers,
+            orelse,
+            finalbody,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action146<
->(
+fn __action146(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
     (_, finalbody, _): (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
         let handlers = vec![];
         let orelse = vec![];
         let end_location = finalbody.last().unwrap().end();
-        ast::Stmt::Try(
-            ast::StmtTry {
-                body,
-                handlers,
-                orelse,
-                finalbody,
-                range: (location..end_location).into()
-            },
-        )
+        ast::Stmt::Try(ast::StmtTry {
+            body,
+            handlers,
+            orelse,
+            finalbody,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action147<
->(
+fn __action147(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, typ, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler
-{
+) -> ast::ExceptHandler {
     {
         let end_location = body.last().unwrap().end();
-        ast::ExceptHandler::ExceptHandler(
-            ast::ExceptHandlerExceptHandler {
-                type_: Some(Box::new(typ)),
-                name: None,
-                body,
-                range: (location..end_location).into()
-            },
-        )
+        ast::ExceptHandler::ExceptHandler(ast::ExceptHandlerExceptHandler {
+            type_: Some(Box::new(typ)),
+            name: None,
+            body,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action148<
->(
+fn __action148(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, x, _): (TextSize, (ast::Expr, ast::Identifier), TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler
-{
+) -> ast::ExceptHandler {
     {
         let end_location = body.last().unwrap().end();
-        ast::ExceptHandler::ExceptHandler(
-            ast::ExceptHandlerExceptHandler {
-                type_: Some(Box::new(x.0)),
-                name: Some(x.1),
-                body,
-                range: (location..end_location).into()
-            },
-        )
+        ast::ExceptHandler::ExceptHandler(ast::ExceptHandlerExceptHandler {
+            type_: Some(Box::new(x.0)),
+            name: Some(x.1),
+            body,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action149<
->(
+fn __action149(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, typ, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler
-{
+) -> ast::ExceptHandler {
     {
         let end_location = body.last().unwrap().end();
-        ast::ExceptHandler::ExceptHandler(
-            ast::ExceptHandlerExceptHandler {
-                type_: typ.map(Box::new),
-                name: None,
-                body,
-                range: (location..end_location).into()
-            },
-        )
+        ast::ExceptHandler::ExceptHandler(ast::ExceptHandlerExceptHandler {
+            type_: typ.map(Box::new),
+            name: None,
+            body,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action150<
->(
+fn __action150(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, x, _): (TextSize, (ast::Expr, ast::Identifier), TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler
-{
+) -> ast::ExceptHandler {
     {
         let end_location = body.last().unwrap().end();
-        ast::ExceptHandler::ExceptHandler(
-            ast::ExceptHandlerExceptHandler {
-                type_: Some(Box::new(x.0)),
-                name: Some(x.1),
-                body,
-                range: (location..end_location).into()
-            },
-        )
+        ast::ExceptHandler::ExceptHandler(ast::ExceptHandlerExceptHandler {
+            type_: Some(Box::new(x.0)),
+            name: Some(x.1),
+            body,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action151<
->(
+fn __action151(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, is_async, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, items, _): (TextSize, Vec<ast::WithItem>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
         let end_location = body.last().unwrap().end();
         let type_comment = None;
         if is_async.is_some() {
-            ast::StmtAsyncWith { items, body, type_comment, range: (location..end_location).into() }.into()
+            ast::StmtAsyncWith {
+                items,
+                body,
+                type_comment,
+                range: (location..end_location).into(),
+            }
+            .into()
         } else {
-            ast::StmtWith { items, body, type_comment, range: (location..end_location).into() }.into()
+            ast::StmtWith {
+                items,
+                body,
+                type_comment,
+                range: (location..end_location).into(),
+            }
+            .into()
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action152<
->(
+fn __action152(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, Vec<ast::WithItem>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action153<
->(
+fn __action153(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, left, _): (TextSize, core::option::Option<Vec<ast::WithItem>>, TextSize),
     (_, mid, _): (TextSize, ast::WithItem, TextSize),
     (_, right, _): (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     {
-        left.into_iter().flatten().chain([mid]).chain(right).collect()
+        left.into_iter()
+            .flatten()
+            .chain([mid])
+            .chain(right)
+            .collect()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action154<
->(
-    (_, __0, _): (TextSize, ast::WithItem, TextSize),
-) -> Vec<ast::WithItem>
-{
+fn __action154((_, __0, _): (TextSize, ast::WithItem, TextSize)) -> Vec<ast::WithItem> {
     vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action155<
->(
+fn __action155(
     (_, item, _): (TextSize, ast::WithItem, TextSize),
     (_, items, _): (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     {
         [item].into_iter().chain(items).collect()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action156<
->(
+fn __action156(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, all, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     {
-        all.into_iter().map(|context_expr| ast::WithItem { context_expr, optional_vars: None, range: optional_range(location, end_location) }).collect()
+        all.into_iter()
+            .map(|context_expr| ast::WithItem {
+                context_expr,
+                optional_vars: None,
+                range: optional_range(location, end_location),
+            })
+            .collect()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action157<
->(
+fn __action157(
     (_, decorator_list, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, is_async, _): (TextSize, core::option::Option<token::Tok>, TextSize),
@@ -31061,670 +30679,565 @@ fn __action157<
     (_, r, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
         let args = Box::new(args);
         let returns = r.map(|x| Box::new(x));
         let end_location = body.last().unwrap().end();
         let type_comment = None;
         if is_async.is_some() {
-            ast::StmtAsyncFunctionDef { name, args, body, decorator_list, returns, type_comment, range: (location..end_location).into() }.into()
+            ast::StmtAsyncFunctionDef {
+                name,
+                args,
+                body,
+                decorator_list,
+                returns,
+                type_comment,
+                range: (location..end_location).into(),
+            }
+            .into()
         } else {
-            ast::StmtFunctionDef { name, args, body, decorator_list, returns, type_comment, range: (location..end_location).into() }.into()
+            ast::StmtFunctionDef {
+                name,
+                args,
+                body,
+                decorator_list,
+                returns,
+                type_comment,
+                range: (location..end_location).into(),
+            }
+            .into()
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action158<
->(
+fn __action158(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, a, _): (TextSize, core::option::Option<ast::Arguments>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     {
         a.as_ref().map(validate_arguments).transpose()?;
-        let args = a
-            .unwrap_or_else(|| ast::Arguments::empty(optional_range(location, end_location)));
+        let args =
+            a.unwrap_or_else(|| ast::Arguments::empty(optional_range(location, end_location)));
 
         Ok(args)
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action159<
->(
+fn __action159(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, arg, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::ArgWithDefault
-{
+) -> ast::ArgWithDefault {
     {
-        let def = ast::Arg { arg, annotation: None, type_comment: None, range: (location..end_location).into() };
-        ast::ArgWithDefault { def, default: None, range: optional_range(location, end_location) }
+        let def = ast::Arg {
+            arg,
+            annotation: None,
+            type_comment: None,
+            range: (location..end_location).into(),
+        };
+        ast::ArgWithDefault {
+            def,
+            default: None,
+            range: optional_range(location, end_location),
+        }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action160<
->(
+fn __action160(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, arg, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Arg
-{
-    ast::Arg { arg, annotation: None, type_comment: None, range: (location..end_location).into() }
+) -> ast::Arg {
+    ast::Arg {
+        arg,
+        annotation: None,
+        type_comment: None,
+        range: (location..end_location).into(),
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action161<
->(
+fn __action161(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, arg, _): (TextSize, ast::Identifier, TextSize),
     (_, a, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::ArgWithDefault
-{
+) -> ast::ArgWithDefault {
     {
         let annotation = a.map(Box::new);
-        let def = ast::Arg { arg, annotation, type_comment: None, range: (location..end_location).into() };
-        ast::ArgWithDefault { def, default: None, range: optional_range(location, end_location) }
+        let def = ast::Arg {
+            arg,
+            annotation,
+            type_comment: None,
+            range: (location..end_location).into(),
+        };
+        ast::ArgWithDefault {
+            def,
+            default: None,
+            range: optional_range(location, end_location),
+        }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action162<
->(
+fn __action162(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, arg, _): (TextSize, ast::Identifier, TextSize),
     (_, a, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Arg
-{
+) -> ast::Arg {
     {
         let annotation = a.map(Box::new);
-        ast::Arg { arg, annotation, type_comment: None, range: (location..end_location).into() }
+        ast::Arg {
+            arg,
+            annotation,
+            type_comment: None,
+            range: (location..end_location).into(),
+        }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action163<
->(
+fn __action163(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, arg, _): (TextSize, ast::Identifier, TextSize),
     (_, a, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Arg
-{
+) -> ast::Arg {
     {
         let annotation = a.map(Box::new);
-        ast::Arg { arg, annotation, type_comment: None, range: (location..end_location).into() }
+        ast::Arg {
+            arg,
+            annotation,
+            type_comment: None,
+            range: (location..end_location).into(),
+        }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action164<
->(
+fn __action164(
     (_, decorator_list, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, name, _): (TextSize, ast::Identifier, TextSize),
-    (_, a, _): (TextSize, core::option::Option<(token::Tok, ArgumentList, token::Tok)>, TextSize),
+    (_, a, _): (
+        TextSize,
+        core::option::Option<(token::Tok, ArgumentList, token::Tok)>,
+        TextSize,
+    ),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     {
         let (bases, keywords) = match a {
             Some((_, arg, _)) => (arg.args, arg.keywords),
             None => (vec![], vec![]),
         };
         let end_location = body.last().unwrap().end();
-        ast::Stmt::ClassDef(
-            ast::StmtClassDef {
-                name,
-                bases,
-                keywords,
-                body,
-                decorator_list,
-                range: (location..end_location).into()
-            },
-        )
+        ast::Stmt::ClassDef(ast::StmtClassDef {
+            name,
+            bases,
+            keywords,
+            body,
+            decorator_list,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action165<
->(
+fn __action165(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, p, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
         p
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action166<
->(
+fn __action166(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, value, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Yield(
-        ast::ExprYield { value: value.map(Box::new), range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::Yield(ast::ExprYield {
+        value: value.map(Box::new),
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action167<
->(
+fn __action167(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::YieldFrom(
-        ast::ExprYieldFrom { value: Box::new(e), range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::YieldFrom(ast::ExprYieldFrom {
+        value: Box::new(e),
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action168<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action168((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action169<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action169((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action170<
->(
+fn __action170(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, id, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, value, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
-    {
-        ast::Expr::NamedExpr(
-            ast::ExprNamedExpr {
-                target: Box::new(ast::Expr::Name(
-                    ast::ExprName { id, ctx: ast::ExprContext::Store, range: (location..end_location).into() },
-                )),
-                range: (location..value.end()).into(),
-                value: Box::new(value),
-            }
-        )
+) -> ast::Expr {
+    {
+        ast::Expr::NamedExpr(ast::ExprNamedExpr {
+            target: Box::new(ast::Expr::Name(ast::ExprName {
+                id,
+                ctx: ast::ExprContext::Store,
+                range: (location..end_location).into(),
+            })),
+            range: (location..value.end()).into(),
+            value: Box::new(value),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action171<
->(
+fn __action171(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, p, _): (TextSize, core::option::Option<ast::Arguments>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     {
         p.as_ref().map(validate_arguments).transpose()?;
-        let p = p
-            .unwrap_or_else(|| ast::Arguments::empty(optional_range(location, end_location)));
+        let p = p.unwrap_or_else(|| ast::Arguments::empty(optional_range(location, end_location)));
 
-        Ok(ast::Expr::Lambda(
-            ast::ExprLambda {
-                args: Box::new(p),
-                body: Box::new(body),
-                range: (location..end_location).into()
-            }
-        ))
+        Ok(ast::Expr::Lambda(ast::ExprLambda {
+            args: Box::new(p),
+            body: Box::new(body),
+            range: (location..end_location).into(),
+        }))
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action172<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::CmpOp
-{
+fn __action172((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::CmpOp {
     ast::CmpOp::Eq
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action173<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::CmpOp
-{
+fn __action173((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::CmpOp {
     ast::CmpOp::NotEq
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action174<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::CmpOp
-{
+fn __action174((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::CmpOp {
     ast::CmpOp::Lt
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action175<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::CmpOp
-{
+fn __action175((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::CmpOp {
     ast::CmpOp::LtE
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action176<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::CmpOp
-{
+fn __action176((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::CmpOp {
     ast::CmpOp::Gt
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action177<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::CmpOp
-{
+fn __action177((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::CmpOp {
     ast::CmpOp::GtE
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action178<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::CmpOp
-{
+fn __action178((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::CmpOp {
     ast::CmpOp::In
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action179<
->(
+fn __action179(
     (_, __0, _): (TextSize, token::Tok, TextSize),
     (_, __1, _): (TextSize, token::Tok, TextSize),
-) -> ast::CmpOp
-{
+) -> ast::CmpOp {
     ast::CmpOp::NotIn
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action180<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::CmpOp
-{
+fn __action180((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::CmpOp {
     ast::CmpOp::Is
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action181<
->(
+fn __action181(
     (_, __0, _): (TextSize, token::Tok, TextSize),
     (_, __1, _): (TextSize, token::Tok, TextSize),
-) -> ast::CmpOp
-{
+) -> ast::CmpOp {
     ast::CmpOp::IsNot
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action182<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Operator
-{
+fn __action182((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
     ast::Operator::LShift
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action183<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Operator
-{
+fn __action183((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
     ast::Operator::RShift
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action184<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Operator
-{
+fn __action184((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
     ast::Operator::Add
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action185<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Operator
-{
+fn __action185((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
     ast::Operator::Sub
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action186<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Operator
-{
+fn __action186((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
     ast::Operator::Mult
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action187<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Operator
-{
+fn __action187((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
     ast::Operator::Div
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action188<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Operator
-{
+fn __action188((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
     ast::Operator::FloorDiv
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action189<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Operator
-{
+fn __action189((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
     ast::Operator::Mod
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action190<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::Operator
-{
+fn __action190((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
     ast::Operator::MatMult
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action191<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::UnaryOp
-{
+fn __action191((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::UnaryOp {
     ast::UnaryOp::UAdd
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action192<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::UnaryOp
-{
+fn __action192((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::UnaryOp {
     ast::UnaryOp::USub
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action193<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> ast::UnaryOp
-{
+fn __action193((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::UnaryOp {
     ast::UnaryOp::Invert
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action194<
->(
+fn __action194(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, s1, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
         s1
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action195<
->(
+fn __action195(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, s1, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
-        ast::Expr::Tuple(
-            ast::ExprTuple { elts: vec![s1], ctx: ast::ExprContext::Load, range: (location..end_location).into() },
-        )
+        ast::Expr::Tuple(ast::ExprTuple {
+            elts: vec![s1],
+            ctx: ast::ExprContext::Load,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action196<
->(
+fn __action196(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, elts, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
-        ast::Expr::Tuple(
-            ast::ExprTuple { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() },
-        )
+        ast::Expr::Tuple(ast::ExprTuple {
+            elts,
+            ctx: ast::ExprContext::Load,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action197<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action197((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action198<
->(
+fn __action198(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e1, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, e3, _): (TextSize, core::option::Option<Option<ast::Expr>>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
         let lower = e1.map(Box::new);
         let upper = e2.map(Box::new);
         let step = e3.flatten().map(Box::new);
-        ast::Expr::Slice(
-            ast::ExprSlice { lower, upper, step, range: (location..end_location).into() }
-        )
+        ast::Expr::Slice(ast::ExprSlice {
+            lower,
+            upper,
+            step,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action199<
->(
+fn __action199(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
-) -> Option<ast::Expr>
-{
+) -> Option<ast::Expr> {
     e
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action200<
->(
+fn __action200(
     (_, e, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
-) -> Vec<ast::Expr>
-{
+) -> Vec<ast::Expr> {
     e
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action201<
->(
+fn __action201(
     (_, elements, _): (TextSize, Vec<(Option<Box<ast::Expr>>, ast::Expr)>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
-) -> Vec<(Option<Box<ast::Expr>>, ast::Expr)>
-{
+) -> Vec<(Option<Box<ast::Expr>>, ast::Expr)> {
     elements
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action202<
->(
+fn __action202(
     (_, e1, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, ast::Expr, TextSize),
-) -> (ast::Expr, ast::Expr)
-{
+) -> (ast::Expr, ast::Expr) {
     (e1, e2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action203<
->(
+fn __action203(
     (_, e, _): (TextSize, (ast::Expr, ast::Expr), TextSize),
-) -> (Option<Box<ast::Expr>>, ast::Expr)
-{
+) -> (Option<Box<ast::Expr>>, ast::Expr) {
     (Some(Box::new(e.0)), e.1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action204<
->(
+fn __action204(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> (Option<Box<ast::Expr>>, ast::Expr)
-{
+) -> (Option<Box<ast::Expr>>, ast::Expr) {
     (None, e)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action205<
->(
+fn __action205(
     (_, e1, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
-) -> Vec<ast::Expr>
-{
+) -> Vec<ast::Expr> {
     e1
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action206<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action206((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action207<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action207((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action208<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action208((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action209<
->(
+fn __action209(
     (_, elements, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
-) -> Vec<ast::Expr>
-{
+) -> Vec<ast::Expr> {
     elements
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action210<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action210((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action211<
->(
+fn __action211(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Starred(
-        ast::ExprStarred { value: Box::new(e), ctx: ast::ExprContext::Load, range: (location..end_location).into() },
-    )
+) -> ast::Expr {
+    ast::Expr::Starred(ast::ExprStarred {
+        value: Box::new(e),
+        ctx: ast::ExprContext::Load,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action212<
->(
+fn __action212(
     (_, c, _): (TextSize, alloc::vec::Vec<ast::Comprehension>, TextSize),
-) -> Vec<ast::Comprehension>
-{
+) -> Vec<ast::Comprehension> {
     c
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action213<
->(
+fn __action213(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, is_async, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -31733,8 +31246,7 @@ fn __action213<
     (_, iter, _): (TextSize, ast::Expr, TextSize),
     (_, ifs, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Comprehension
-{
+) -> ast::Comprehension {
     {
         let is_async = is_async.is_some();
         ast::Comprehension {
@@ -31742,36 +31254,35 @@ fn __action213<
             iter,
             ifs,
             is_async,
-            range: optional_range(location, end_location)
+            range: optional_range(location, end_location),
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action214<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action214((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action215<
->(
+fn __action215(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, c, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     c
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action216<
->(
-    (_, e, _): (TextSize, Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
-) -> Result<ArgumentList,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+fn __action216(
+    (_, e, _): (
+        TextSize,
+        Vec<(
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        )>,
+        TextSize,
+    ),
+) -> Result<ArgumentList, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     {
         let arg_list = parse_args(e)?;
         Ok(arg_list)
@@ -31779,23 +31290,26 @@ fn __action216<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action217<
->(
+fn __action217(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-    (_, c, _): (TextSize, core::option::Option<Vec<ast::Comprehension>>, TextSize),
+    (_, c, _): (
+        TextSize,
+        core::option::Option<Vec<ast::Comprehension>>,
+        TextSize,
+    ),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
-{
+) -> (
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+) {
     {
         let expr = match c {
-            Some(c) => ast::Expr::GeneratorExp(
-                ast::ExprGeneratorExp {
-                    elt: Box::new(e),
-                    generators: c,
-                    range: (location..end_location).into()
-                }
-            ),
+            Some(c) => ast::Expr::GeneratorExp(ast::ExprGeneratorExp {
+                elt: Box::new(e),
+                generators: c,
+                range: (location..end_location).into(),
+            }),
             None => e,
         };
         (None, expr)
@@ -31803,109 +31317,112 @@ fn __action217<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action218<
->(
+fn __action218(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, i, _): (TextSize, ast::Identifier, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
-{
+) -> (
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+) {
     (Some((location, end_location, Some(i))), e)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action219<
->(
+fn __action219(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
-{
+) -> (
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+) {
     {
-        let expr = ast::Expr::Starred(
-            ast::ExprStarred { value: Box::new(e), ctx: ast::ExprContext::Load, range: (location..end_location).into() },
-        );
+        let expr = ast::Expr::Starred(ast::ExprStarred {
+            value: Box::new(e),
+            ctx: ast::ExprContext::Load,
+            range: (location..end_location).into(),
+        });
         (None, expr)
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action220<
->(
+fn __action220(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
-{
+) -> (
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+) {
     (Some((location, end_location, None)), e)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action221<
->(
-    (_, value, _): (TextSize, BigInt, TextSize),
-) -> ast::Constant
-{
+fn __action221((_, value, _): (TextSize, BigInt, TextSize)) -> ast::Constant {
     ast::Constant::Int(value)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action222<
->(
-    (_, value, _): (TextSize, f64, TextSize),
-) -> ast::Constant
-{
+fn __action222((_, value, _): (TextSize, f64, TextSize)) -> ast::Constant {
     ast::Constant::Float(value)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action223<
->(
-    (_, s, _): (TextSize, (f64, f64), TextSize),
-) -> ast::Constant
-{
-    ast::Constant::Complex { real: s.0, imag: s.1 }
+fn __action223((_, s, _): (TextSize, (f64, f64), TextSize)) -> ast::Constant {
+    ast::Constant::Complex {
+        real: s.0,
+        imag: s.1,
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action224<
->(
-    (_, s, _): (TextSize, String, TextSize),
-) -> ast::Identifier
-{
+fn __action224((_, s, _): (TextSize, String, TextSize)) -> ast::Identifier {
     ast::Identifier::new(s)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action225<
->(
+fn __action225(
     (_, __0, _): (TextSize, Vec<ast::Comprehension>, TextSize),
-) -> core::option::Option<Vec<ast::Comprehension>>
-{
+) -> core::option::Option<Vec<ast::Comprehension>> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action226<
->(
+fn __action226(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<Vec<ast::Comprehension>>
-{
+) -> core::option::Option<Vec<ast::Comprehension>> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action227<
->(
-    (_, mut v, _): (TextSize, alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
-    (_, last, _): (TextSize, core::option::Option<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
-) -> Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
-{
+fn __action227(
+    (_, mut v, _): (
+        TextSize,
+        alloc::vec::Vec<(
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        )>,
+        TextSize,
+    ),
+    (_, last, _): (
+        TextSize,
+        core::option::Option<(
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        )>,
+        TextSize,
+    ),
+) -> Vec<(
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+)> {
     {
         if let Some(element) = last {
             v.push(element);
@@ -31915,106 +31432,89 @@ fn __action227<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action228<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> alloc::vec::Vec<ast::Expr>
-{
+fn __action228(__lookbehind: &TextSize, __lookahead: &TextSize) -> alloc::vec::Vec<ast::Expr> {
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action229<
->(
+fn __action229(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
-) -> alloc::vec::Vec<ast::Expr>
-{
+) -> alloc::vec::Vec<ast::Expr> {
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action230<
->(
+fn __action230(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, mut values, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, last, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
         values.push(last);
-        ast::Expr::BoolOp(
-            ast::ExprBoolOp { op: ast::BoolOp::Or, values, range: (location..end_location).into() }
-        )
+        ast::Expr::BoolOp(ast::ExprBoolOp {
+            op: ast::BoolOp::Or,
+            values,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action231<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action231((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action232<
->(
+fn __action232(
     (_, __0, _): (TextSize, ast::Comprehension, TextSize),
-) -> alloc::vec::Vec<ast::Comprehension>
-{
+) -> alloc::vec::Vec<ast::Comprehension> {
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action233<
->(
+fn __action233(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Comprehension>, TextSize),
     (_, e, _): (TextSize, ast::Comprehension, TextSize),
-) -> alloc::vec::Vec<ast::Comprehension>
-{
-    { let mut v = v; v.push(e); v }
+) -> alloc::vec::Vec<ast::Comprehension> {
+    {
+        let mut v = v;
+        v.push(e);
+        v
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action234<
->(
+fn __action234(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, elts, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, trailing_comma, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
         if elts.len() == 1 && trailing_comma.is_none() {
             elts.into_iter().next().unwrap()
         } else {
-            ast::Expr::Tuple(
-                ast::ExprTuple { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() }
-            )
+            ast::Expr::Tuple(ast::ExprTuple {
+                elts,
+                ctx: ast::ExprContext::Load,
+                range: (location..end_location).into(),
+            })
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action235<
->(
-    (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> Vec<ast::Expr>
-{
+fn __action235((_, e, _): (TextSize, ast::Expr, TextSize)) -> Vec<ast::Expr> {
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action236<
->(
+fn __action236(
     (_, mut v, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> Vec<ast::Expr>
-{
+) -> Vec<ast::Expr> {
     {
         v.push(e);
         v
@@ -32022,66 +31522,59 @@ fn __action236<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action237<
->(
+fn __action237(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, elts, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, trailing_comma, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
         if elts.len() == 1 && trailing_comma.is_none() {
             elts.into_iter().next().unwrap()
         } else {
-            ast::Expr::Tuple(
-                ast::ExprTuple { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() }
-            )
+            ast::Expr::Tuple(ast::ExprTuple {
+                elts,
+                ctx: ast::ExprContext::Load,
+                range: (location..end_location).into(),
+            })
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action238<
->(
+fn __action238(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e1, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::BinOp(
-        ast::ExprBinOp { left: Box::new(e1), op: ast::Operator::BitOr, right: Box::new(e2), range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::BinOp(ast::ExprBinOp {
+        left: Box::new(e1),
+        op: ast::Operator::BitOr,
+        right: Box::new(e2),
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action239<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action239((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action240<
->(
+fn __action240(
     (_, e, _): (TextSize, (Option<Box<ast::Expr>>, ast::Expr), TextSize),
-) -> Vec<(Option<Box<ast::Expr>>, ast::Expr)>
-{
+) -> Vec<(Option<Box<ast::Expr>>, ast::Expr)> {
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action241<
->(
+fn __action241(
     (_, mut v, _): (TextSize, Vec<(Option<Box<ast::Expr>>, ast::Expr)>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, (Option<Box<ast::Expr>>, ast::Expr), TextSize),
-) -> Vec<(Option<Box<ast::Expr>>, ast::Expr)>
-{
+) -> Vec<(Option<Box<ast::Expr>>, ast::Expr)> {
     {
         v.push(e);
         v
@@ -32089,22 +31582,16 @@ fn __action241<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action242<
->(
-    (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> Vec<ast::Expr>
-{
+fn __action242((_, e, _): (TextSize, ast::Expr, TextSize)) -> Vec<ast::Expr> {
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action243<
->(
+fn __action243(
     (_, mut v, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> Vec<ast::Expr>
-{
+) -> Vec<ast::Expr> {
     {
         v.push(e);
         v
@@ -32112,43 +31599,35 @@ fn __action243<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action244<
->(
+fn __action244(
     (_, __0, _): (TextSize, Option<ast::Expr>, TextSize),
-) -> core::option::Option<Option<ast::Expr>>
-{
+) -> core::option::Option<Option<ast::Expr>> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action245<
->(
+fn __action245(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<Option<ast::Expr>>
-{
+) -> core::option::Option<Option<ast::Expr>> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action246<
->(
+fn __action246(
     (_, e1, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, ast::Expr, TextSize),
-) -> Vec<ast::Expr>
-{
+) -> Vec<ast::Expr> {
     vec![e1, e2]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action247<
->(
+fn __action247(
     (_, mut v, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> Vec<ast::Expr>
-{
+) -> Vec<ast::Expr> {
     {
         v.push(e);
         v
@@ -32156,34 +31635,40 @@ fn __action247<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action248<
->(
+fn __action248(
     (_, __0, _): (TextSize, ast::Arguments, TextSize),
-) -> core::option::Option<ast::Arguments>
-{
+) -> core::option::Option<ast::Arguments> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action249<
->(
+fn __action249(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<ast::Arguments>
-{
+) -> core::option::Option<ast::Arguments> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action250<
->(
+fn __action250(
     (_, location, _): (TextSize, TextSize, TextSize),
-    (_, param1, _): (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
-    (_, args2, _): (TextSize, core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>, TextSize),
+    (_, param1, _): (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
+    (_, args2, _): (
+        TextSize,
+        core::option::Option<(
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        )>,
+        TextSize,
+    ),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     {
         validate_pos_params(&param1)?;
         let (posonlyargs, args) = param1;
@@ -32197,21 +31682,23 @@ fn __action250<
             kwonlyargs,
             vararg,
             kwarg,
-            range: optional_range(location, end_location)
+            range: optional_range(location, end_location),
         })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action251<
->(
+fn __action251(
     (_, location, _): (TextSize, TextSize, TextSize),
-    (_, param1, _): (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+    (_, param1, _): (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     (_, kw, _): (TextSize, Option<Box<ast::Arg>>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     {
         validate_pos_params(&param1)?;
         let (posonlyargs, args) = param1;
@@ -32227,20 +31714,26 @@ fn __action251<
             kwonlyargs,
             vararg,
             kwarg,
-            range: optional_range(location, end_location)
+            range: optional_range(location, end_location),
         })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action252<
->(
+fn __action252(
     (_, location, _): (TextSize, TextSize, TextSize),
-    (_, params, _): (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
+    (_, params, _): (
+        TextSize,
+        (
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        ),
+        TextSize,
+    ),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Arguments
-{
+) -> ast::Arguments {
     {
         let (vararg, kwonlyargs, kwarg) = params;
         ast::Arguments {
@@ -32249,20 +31742,18 @@ fn __action252<
             kwonlyargs,
             vararg,
             kwarg,
-            range: optional_range(location, end_location)
+            range: optional_range(location, end_location),
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action253<
->(
+fn __action253(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, kwarg, _): (TextSize, Option<Box<ast::Arg>>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Arguments
-{
+) -> ast::Arguments {
     {
         ast::Arguments {
             posonlyargs: vec![],
@@ -32270,137 +31761,111 @@ fn __action253<
             kwonlyargs: vec![],
             vararg: None,
             kwarg,
-            range: optional_range(location, end_location)
+            range: optional_range(location, end_location),
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action254<
->(
+fn __action254(
     (_, __0, _): (TextSize, (token::Tok, ArgumentList, token::Tok), TextSize),
-) -> core::option::Option<(token::Tok, ArgumentList, token::Tok)>
-{
+) -> core::option::Option<(token::Tok, ArgumentList, token::Tok)> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action255<
->(
+fn __action255(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<(token::Tok, ArgumentList, token::Tok)>
-{
+) -> core::option::Option<(token::Tok, ArgumentList, token::Tok)> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action256<
->(
+fn __action256(
     (_, __0, _): (TextSize, token::Tok, TextSize),
     (_, __1, _): (TextSize, ArgumentList, TextSize),
     (_, __2, _): (TextSize, token::Tok, TextSize),
-) -> (token::Tok, ArgumentList, token::Tok)
-{
+) -> (token::Tok, ArgumentList, token::Tok) {
     (__0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action257<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> core::option::Option<ast::Expr>
-{
+fn __action257((_, __0, _): (TextSize, ast::Expr, TextSize)) -> core::option::Option<ast::Expr> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action258<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> core::option::Option<ast::Expr>
-{
+fn __action258(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Expr> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action259<
->(
+fn __action259(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action260<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> core::option::Option<ast::Expr>
-{
+fn __action260((_, __0, _): (TextSize, ast::Expr, TextSize)) -> core::option::Option<ast::Expr> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action261<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> core::option::Option<ast::Expr>
-{
+fn __action261(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Expr> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action262<
->(
+fn __action262(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action263<
->(
+fn __action263(
     (_, __0, _): (TextSize, ast::Arguments, TextSize),
-) -> core::option::Option<ast::Arguments>
-{
+) -> core::option::Option<ast::Arguments> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action264<
->(
+fn __action264(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<ast::Arguments>
-{
+) -> core::option::Option<ast::Arguments> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action265<
->(
-    (_, __0, _): (TextSize, ast::Arguments, TextSize),
-) -> ast::Arguments
-{
+fn __action265((_, __0, _): (TextSize, ast::Arguments, TextSize)) -> ast::Arguments {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action266<
->(
+fn __action266(
     (_, location, _): (TextSize, TextSize, TextSize),
-    (_, param1, _): (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
-    (_, args2, _): (TextSize, core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>, TextSize),
+    (_, param1, _): (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
+    (_, args2, _): (
+        TextSize,
+        core::option::Option<(
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        )>,
+        TextSize,
+    ),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     {
         validate_pos_params(&param1)?;
         let (posonlyargs, args) = param1;
@@ -32414,21 +31879,23 @@ fn __action266<
             kwonlyargs,
             vararg,
             kwarg,
-            range: optional_range(location, end_location)
+            range: optional_range(location, end_location),
         })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action267<
->(
+fn __action267(
     (_, location, _): (TextSize, TextSize, TextSize),
-    (_, param1, _): (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+    (_, param1, _): (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     (_, kw, _): (TextSize, Option<Box<ast::Arg>>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     {
         validate_pos_params(&param1)?;
         let (posonlyargs, args) = param1;
@@ -32444,20 +31911,26 @@ fn __action267<
             kwonlyargs,
             vararg,
             kwarg,
-            range: optional_range(location, end_location)
+            range: optional_range(location, end_location),
         })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action268<
->(
+fn __action268(
     (_, location, _): (TextSize, TextSize, TextSize),
-    (_, params, _): (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
+    (_, params, _): (
+        TextSize,
+        (
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        ),
+        TextSize,
+    ),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Arguments
-{
+) -> ast::Arguments {
     {
         let (vararg, kwonlyargs, kwarg) = params;
         ast::Arguments {
@@ -32466,20 +31939,18 @@ fn __action268<
             kwonlyargs,
             vararg,
             kwarg,
-            range: optional_range(location, end_location)
+            range: optional_range(location, end_location),
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action269<
->(
+fn __action269(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, kwarg, _): (TextSize, Option<Box<ast::Arg>>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Arguments
-{
+) -> ast::Arguments {
     {
         ast::Arguments {
             posonlyargs: vec![],
@@ -32487,76 +31958,52 @@ fn __action269<
             kwonlyargs: vec![],
             vararg: None,
             kwarg,
-            range: optional_range(location, end_location)
+            range: optional_range(location, end_location),
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action270<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> core::option::Option<ast::Expr>
-{
+fn __action270((_, __0, _): (TextSize, ast::Expr, TextSize)) -> core::option::Option<ast::Expr> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action271<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> core::option::Option<ast::Expr>
-{
+fn __action271(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Expr> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action272<
->(
+fn __action272(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action273<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> alloc::vec::Vec<ast::Expr>
-{
+fn __action273(__lookbehind: &TextSize, __lookahead: &TextSize) -> alloc::vec::Vec<ast::Expr> {
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action274<
->(
+fn __action274(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
-) -> alloc::vec::Vec<ast::Expr>
-{
+) -> alloc::vec::Vec<ast::Expr> {
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action275<
->(
-    (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> Vec<ast::Expr>
-{
+fn __action275((_, e, _): (TextSize, ast::Expr, TextSize)) -> Vec<ast::Expr> {
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action276<
->(
+fn __action276(
     (_, mut v, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> Vec<ast::Expr>
-{
+) -> Vec<ast::Expr> {
     {
         v.push(e);
         v
@@ -32564,348 +32011,302 @@ fn __action276<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action277<
->(
-    (_, __0, _): (TextSize, ast::WithItem, TextSize),
-) -> alloc::vec::Vec<ast::WithItem>
-{
+fn __action277((_, __0, _): (TextSize, ast::WithItem, TextSize)) -> alloc::vec::Vec<ast::WithItem> {
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action278<
->(
+fn __action278(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
     (_, e, _): (TextSize, ast::WithItem, TextSize),
-) -> alloc::vec::Vec<ast::WithItem>
-{
-    { let mut v = v; v.push(e); v }
+) -> alloc::vec::Vec<ast::WithItem> {
+    {
+        let mut v = v;
+        v.push(e);
+        v
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action279<
->(
+fn __action279(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, context_expr, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::WithItem
-{
-    ast::WithItem { context_expr, optional_vars: None, range: optional_range(location, end_location) }
+) -> ast::WithItem {
+    ast::WithItem {
+        context_expr,
+        optional_vars: None,
+        range: optional_range(location, end_location),
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action280<
->(
+fn __action280(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, context_expr, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, vars, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::WithItem
-{
+) -> ast::WithItem {
     {
         let optional_vars = Some(Box::new(set_context(vars, ast::ExprContext::Store)));
-        ast::WithItem { context_expr, optional_vars, range: optional_range(location, end_location) }
+        ast::WithItem {
+            context_expr,
+            optional_vars,
+            range: optional_range(location, end_location),
+        }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action281<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> alloc::vec::Vec<ast::WithItem>
-{
+fn __action281(__lookbehind: &TextSize, __lookahead: &TextSize) -> alloc::vec::Vec<ast::WithItem> {
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action282<
->(
+fn __action282(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
-) -> alloc::vec::Vec<ast::WithItem>
-{
+) -> alloc::vec::Vec<ast::WithItem> {
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action283<
->(
+fn __action283(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::WithItem, TextSize),
-) -> ast::WithItem
-{
+) -> ast::WithItem {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action284<
->(
+fn __action284(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, context_expr, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::WithItem
-{
-    ast::WithItem { context_expr, optional_vars: None, range: optional_range(location, end_location) }
+) -> ast::WithItem {
+    ast::WithItem {
+        context_expr,
+        optional_vars: None,
+        range: optional_range(location, end_location),
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action285<
->(
+fn __action285(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, context_expr, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, vars, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::WithItem
-{
+) -> ast::WithItem {
     {
         let optional_vars = Some(Box::new(set_context(vars, ast::ExprContext::Store)));
-        ast::WithItem { context_expr, optional_vars, range: optional_range(location, end_location) }
+        ast::WithItem {
+            context_expr,
+            optional_vars,
+            range: optional_range(location, end_location),
+        }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action286<
->(
+fn __action286(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, context_expr, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, vars, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::WithItem
-{
+) -> ast::WithItem {
     {
         let optional_vars = Some(Box::new(set_context(vars, ast::ExprContext::Store)));
-        ast::WithItem { context_expr, optional_vars, range: optional_range(location, end_location) }
+        ast::WithItem {
+            context_expr,
+            optional_vars,
+            range: optional_range(location, end_location),
+        }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action287<
->(
+fn __action287(
     (_, __0, _): (TextSize, Vec<ast::WithItem>, TextSize),
-) -> core::option::Option<Vec<ast::WithItem>>
-{
+) -> core::option::Option<Vec<ast::WithItem>> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action288<
->(
+fn __action288(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<Vec<ast::WithItem>>
-{
+) -> core::option::Option<Vec<ast::WithItem>> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action289<
->(
+fn __action289(
     (_, __0, _): (TextSize, Vec<ast::WithItem>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action290<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> core::option::Option<ast::Expr>
-{
+fn __action290((_, __0, _): (TextSize, ast::Expr, TextSize)) -> core::option::Option<ast::Expr> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action291<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> core::option::Option<ast::Expr>
-{
+fn __action291(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Expr> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action292<
->(
+fn __action292(
     (_, __0, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __1, _): (TextSize, ast::Identifier, TextSize),
-) -> (ast::Expr, ast::Identifier)
-{
+) -> (ast::Expr, ast::Identifier) {
     (__0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action293<
->(
+fn __action293(
     (_, __0, _): (TextSize, ast::ExceptHandler, TextSize),
-) -> alloc::vec::Vec<ast::ExceptHandler>
-{
+) -> alloc::vec::Vec<ast::ExceptHandler> {
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action294<
->(
+fn __action294(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::ExceptHandler>, TextSize),
     (_, e, _): (TextSize, ast::ExceptHandler, TextSize),
-) -> alloc::vec::Vec<ast::ExceptHandler>
-{
-    { let mut v = v; v.push(e); v }
+) -> alloc::vec::Vec<ast::ExceptHandler> {
+    {
+        let mut v = v;
+        v.push(e);
+        v
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action295<
->(
-    (_, __0, _): (TextSize, ast::Suite, TextSize),
-) -> core::option::Option<ast::Suite>
-{
+fn __action295((_, __0, _): (TextSize, ast::Suite, TextSize)) -> core::option::Option<ast::Suite> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action296<
->(
+fn __action296(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<ast::Suite>
-{
+) -> core::option::Option<ast::Suite> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action297<
->(
+fn __action297(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::Suite, TextSize),
-) -> ast::Suite
-{
+) -> ast::Suite {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action298<
->(
+fn __action298(
     (_, __0, _): (TextSize, ast::ExceptHandler, TextSize),
-) -> alloc::vec::Vec<ast::ExceptHandler>
-{
+) -> alloc::vec::Vec<ast::ExceptHandler> {
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action299<
->(
+fn __action299(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::ExceptHandler>, TextSize),
     (_, e, _): (TextSize, ast::ExceptHandler, TextSize),
-) -> alloc::vec::Vec<ast::ExceptHandler>
-{
-    { let mut v = v; v.push(e); v }
+) -> alloc::vec::Vec<ast::ExceptHandler> {
+    {
+        let mut v = v;
+        v.push(e);
+        v
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action300<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> core::option::Option<token::Tok>
-{
+fn __action300((_, __0, _): (TextSize, token::Tok, TextSize)) -> core::option::Option<token::Tok> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action301<
->(
+fn __action301(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<token::Tok>
-{
+) -> core::option::Option<token::Tok> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action302<
->(
-    (_, __0, _): (TextSize, ast::Suite, TextSize),
-) -> core::option::Option<ast::Suite>
-{
+fn __action302((_, __0, _): (TextSize, ast::Suite, TextSize)) -> core::option::Option<ast::Suite> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action303<
->(
+fn __action303(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<ast::Suite>
-{
+) -> core::option::Option<ast::Suite> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action304<
->(
+fn __action304(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::Suite, TextSize),
-) -> ast::Suite
-{
+) -> ast::Suite {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action305<
->(
+fn __action305(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>
-{
+) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)> {
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action306<
->(
-    (_, v, _): (TextSize, alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>, TextSize),
-) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>
-{
+fn __action306(
+    (_, v, _): (
+        TextSize,
+        alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>,
+        TextSize,
+    ),
+) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)> {
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action307<
->(
+fn __action307(
     (_, __0, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __1, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __2, _): (TextSize, ast::Suite, TextSize),
-) -> (TextSize, ast::Expr, ast::Suite)
-{
+) -> (TextSize, ast::Expr, ast::Suite) {
     (__0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action308<
->(
+fn __action308(
     (_, e, _): (TextSize, (ast::Identifier, ast::Pattern), TextSize),
-) -> Vec<(ast::Identifier, ast::Pattern)>
-{
+) -> Vec<(ast::Identifier, ast::Pattern)> {
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action309<
->(
+fn __action309(
     (_, mut v, _): (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, (ast::Identifier, ast::Pattern), TextSize),
-) -> Vec<(ast::Identifier, ast::Pattern)>
-{
+) -> Vec<(ast::Identifier, ast::Pattern)> {
     {
         v.push(e);
         v
@@ -32913,22 +32314,16 @@ fn __action309<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action310<
->(
-    (_, e, _): (TextSize, ast::Pattern, TextSize),
-) -> Vec<ast::Pattern>
-{
+fn __action310((_, e, _): (TextSize, ast::Pattern, TextSize)) -> Vec<ast::Pattern> {
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action311<
->(
+fn __action311(
     (_, mut v, _): (TextSize, Vec<ast::Pattern>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Pattern, TextSize),
-) -> Vec<ast::Pattern>
-{
+) -> Vec<ast::Pattern> {
     {
         v.push(e);
         v
@@ -32936,22 +32331,18 @@ fn __action311<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action312<
->(
+fn __action312(
     (_, e, _): (TextSize, (ast::Expr, ast::Pattern), TextSize),
-) -> Vec<(ast::Expr, ast::Pattern)>
-{
+) -> Vec<(ast::Expr, ast::Pattern)> {
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action313<
->(
+fn __action313(
     (_, mut v, _): (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, (ast::Expr, ast::Pattern), TextSize),
-) -> Vec<(ast::Expr, ast::Pattern)>
-{
+) -> Vec<(ast::Expr, ast::Pattern)> {
     {
         v.push(e);
         v
@@ -32959,42 +32350,50 @@ fn __action313<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action314<
->(
-    (_, __0, _): (TextSize, (TextSize, (String, StringKind, bool), TextSize), TextSize),
-) -> alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>
-{
+fn __action314(
+    (_, __0, _): (
+        TextSize,
+        (TextSize, (String, StringKind, bool), TextSize),
+        TextSize,
+    ),
+) -> alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)> {
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action315<
->(
-    (_, v, _): (TextSize, alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>, TextSize),
-    (_, e, _): (TextSize, (TextSize, (String, StringKind, bool), TextSize), TextSize),
-) -> alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>
-{
-    { let mut v = v; v.push(e); v }
+fn __action315(
+    (_, v, _): (
+        TextSize,
+        alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>,
+        TextSize,
+    ),
+    (_, e, _): (
+        TextSize,
+        (TextSize, (String, StringKind, bool), TextSize),
+        TextSize,
+    ),
+) -> alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)> {
+    {
+        let mut v = v;
+        v.push(e);
+        v
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action316<
->(
+fn __action316(
     (_, __0, _): (TextSize, TextSize, TextSize),
     (_, __1, _): (TextSize, (String, StringKind, bool), TextSize),
     (_, __2, _): (TextSize, TextSize, TextSize),
-) -> (TextSize, (String, StringKind, bool), TextSize)
-{
+) -> (TextSize, (String, StringKind, bool), TextSize) {
     (__0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action317<
->(
+fn __action317(
     (_, mut v, _): (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     (_, last, _): (TextSize, core::option::Option<ast::Pattern>, TextSize),
-) -> Vec<ast::Pattern>
-{
+) -> Vec<ast::Pattern> {
     {
         if let Some(element) = last {
             v.push(element);
@@ -33004,53 +32403,45 @@ fn __action317<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action318<
->(
-    (_, __0, _): (TextSize, ast::Pattern, TextSize),
-) -> alloc::vec::Vec<ast::Pattern>
-{
+fn __action318((_, __0, _): (TextSize, ast::Pattern, TextSize)) -> alloc::vec::Vec<ast::Pattern> {
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action319<
->(
+fn __action319(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     (_, e, _): (TextSize, ast::Pattern, TextSize),
-) -> alloc::vec::Vec<ast::Pattern>
-{
-    { let mut v = v; v.push(e); v }
+) -> alloc::vec::Vec<ast::Pattern> {
+    {
+        let mut v = v;
+        v.push(e);
+        v
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action320<
->(
+fn __action320(
     (_, __0, _): (TextSize, ast::Pattern, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action321<
->(
+fn __action321(
     (_, e1, _): (TextSize, ast::Pattern, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, ast::Pattern, TextSize),
-) -> Vec<ast::Pattern>
-{
+) -> Vec<ast::Pattern> {
     vec![e1, e2]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action322<
->(
+fn __action322(
     (_, mut v, _): (TextSize, Vec<ast::Pattern>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Pattern, TextSize),
-) -> Vec<ast::Pattern>
-{
+) -> Vec<ast::Pattern> {
     {
         v.push(e);
         v
@@ -33058,24 +32449,20 @@ fn __action322<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action323<
->(
+fn __action323(
     (_, e1, _): (TextSize, ast::Pattern, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, ast::Pattern, TextSize),
-) -> Vec<ast::Pattern>
-{
+) -> Vec<ast::Pattern> {
     vec![e1, e2]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action324<
->(
+fn __action324(
     (_, mut v, _): (TextSize, Vec<ast::Pattern>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Pattern, TextSize),
-) -> Vec<ast::Pattern>
-{
+) -> Vec<ast::Pattern> {
     {
         v.push(e);
         v
@@ -33083,52 +32470,35 @@ fn __action324<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action325<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> core::option::Option<ast::Expr>
-{
+fn __action325((_, __0, _): (TextSize, ast::Expr, TextSize)) -> core::option::Option<ast::Expr> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action326<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> core::option::Option<ast::Expr>
-{
+fn __action326(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Expr> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action327<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action327((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action328<
->(
+fn __action328(
     (_, e1, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, ast::Expr, TextSize),
-) -> Vec<ast::Expr>
-{
+) -> Vec<ast::Expr> {
     vec![e1, e2]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action329<
->(
+fn __action329(
     (_, mut v, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> Vec<ast::Expr>
-{
+) -> Vec<ast::Expr> {
     {
         v.push(e);
         v
@@ -33136,70 +32506,53 @@ fn __action329<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action330<
->(
+fn __action330(
     (_, __0, _): (TextSize, ast::MatchCase, TextSize),
-) -> alloc::vec::Vec<ast::MatchCase>
-{
+) -> alloc::vec::Vec<ast::MatchCase> {
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action331<
->(
+fn __action331(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::MatchCase>, TextSize),
     (_, e, _): (TextSize, ast::MatchCase, TextSize),
-) -> alloc::vec::Vec<ast::MatchCase>
-{
-    { let mut v = v; v.push(e); v }
+) -> alloc::vec::Vec<ast::MatchCase> {
+    {
+        let mut v = v;
+        v.push(e);
+        v
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action332<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> core::option::Option<ast::Expr>
-{
+fn __action332((_, __0, _): (TextSize, ast::Expr, TextSize)) -> core::option::Option<ast::Expr> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action333<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> core::option::Option<ast::Expr>
-{
+fn __action333(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Expr> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action334<
->(
+fn __action334(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action335<
->(
-    (_, e, _): (TextSize, ast::Identifier, TextSize),
-) -> Vec<ast::Identifier>
-{
+fn __action335((_, e, _): (TextSize, ast::Identifier, TextSize)) -> Vec<ast::Identifier> {
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action336<
->(
+fn __action336(
     (_, mut v, _): (TextSize, Vec<ast::Identifier>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Identifier, TextSize),
-) -> Vec<ast::Identifier>
-{
+) -> Vec<ast::Identifier> {
     {
         v.push(e);
         v
@@ -33207,70 +32560,60 @@ fn __action336<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action337<
->(
+fn __action337(
     (_, __0, _): (TextSize, (token::Tok, ast::Identifier), TextSize),
-) -> alloc::vec::Vec<(token::Tok, ast::Identifier)>
-{
+) -> alloc::vec::Vec<(token::Tok, ast::Identifier)> {
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action338<
->(
-    (_, v, _): (TextSize, alloc::vec::Vec<(token::Tok, ast::Identifier)>, TextSize),
+fn __action338(
+    (_, v, _): (
+        TextSize,
+        alloc::vec::Vec<(token::Tok, ast::Identifier)>,
+        TextSize,
+    ),
     (_, e, _): (TextSize, (token::Tok, ast::Identifier), TextSize),
-) -> alloc::vec::Vec<(token::Tok, ast::Identifier)>
-{
-    { let mut v = v; v.push(e); v }
+) -> alloc::vec::Vec<(token::Tok, ast::Identifier)> {
+    {
+        let mut v = v;
+        v.push(e);
+        v
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action339<
->(
+fn __action339(
     (_, __0, _): (TextSize, token::Tok, TextSize),
     (_, __1, _): (TextSize, ast::Identifier, TextSize),
-) -> (token::Tok, ast::Identifier)
-{
+) -> (token::Tok, ast::Identifier) {
     (__0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action340<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> core::option::Option<token::Tok>
-{
+fn __action340((_, __0, _): (TextSize, token::Tok, TextSize)) -> core::option::Option<token::Tok> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action341<
->(
+fn __action341(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<token::Tok>
-{
+) -> core::option::Option<token::Tok> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action342<
->(
-    (_, e, _): (TextSize, ast::Alias, TextSize),
-) -> Vec<ast::Alias>
-{
+fn __action342((_, e, _): (TextSize, ast::Alias, TextSize)) -> Vec<ast::Alias> {
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action343<
->(
+fn __action343(
     (_, mut v, _): (TextSize, Vec<ast::Alias>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Alias, TextSize),
-) -> Vec<ast::Alias>
-{
+) -> Vec<ast::Alias> {
     {
         v.push(e);
         v
@@ -33278,72 +32621,59 @@ fn __action343<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action344<
->(
+fn __action344(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, name, _): (TextSize, ast::Identifier, TextSize),
     (_, a, _): (TextSize, core::option::Option<ast::Identifier>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Alias
-{
-    ast::Alias { name, asname: a, range: (location..end_location).into() }
+) -> ast::Alias {
+    ast::Alias {
+        name,
+        asname: a,
+        range: (location..end_location).into(),
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action345<
->(
-    (_, __0, _): (TextSize, ast::Int, TextSize),
-) -> alloc::vec::Vec<ast::Int>
-{
+fn __action345((_, __0, _): (TextSize, ast::Int, TextSize)) -> alloc::vec::Vec<ast::Int> {
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action346<
->(
+fn __action346(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Int>, TextSize),
     (_, e, _): (TextSize, ast::Int, TextSize),
-) -> alloc::vec::Vec<ast::Int>
-{
-    { let mut v = v; v.push(e); v }
+) -> alloc::vec::Vec<ast::Int> {
+    {
+        let mut v = v;
+        v.push(e);
+        v
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action347<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> alloc::vec::Vec<ast::Int>
-{
+fn __action347(__lookbehind: &TextSize, __lookahead: &TextSize) -> alloc::vec::Vec<ast::Int> {
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action348<
->(
+fn __action348(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Int>, TextSize),
-) -> alloc::vec::Vec<ast::Int>
-{
+) -> alloc::vec::Vec<ast::Int> {
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action349<
->(
-    (_, e, _): (TextSize, ast::Alias, TextSize),
-) -> Vec<ast::Alias>
-{
+fn __action349((_, e, _): (TextSize, ast::Alias, TextSize)) -> Vec<ast::Alias> {
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action350<
->(
+fn __action350(
     (_, mut v, _): (TextSize, Vec<ast::Alias>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Alias, TextSize),
-) -> Vec<ast::Alias>
-{
+) -> Vec<ast::Alias> {
     {
         v.push(e);
         v
@@ -33351,87 +32681,59 @@ fn __action350<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action351<
->(
+fn __action351(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, name, _): (TextSize, ast::Identifier, TextSize),
     (_, a, _): (TextSize, core::option::Option<ast::Identifier>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Alias
-{
-    ast::Alias { name, asname: a, range: (location..end_location).into() }
+) -> ast::Alias {
+    ast::Alias {
+        name,
+        asname: a,
+        range: (location..end_location).into(),
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action352<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> core::option::Option<ast::Expr>
-{
+fn __action352((_, __0, _): (TextSize, ast::Expr, TextSize)) -> core::option::Option<ast::Expr> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action353<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> core::option::Option<ast::Expr>
-{
+fn __action353(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Expr> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action354<
->(
+fn __action354(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action355<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> core::option::Option<ast::Expr>
-{
+fn __action355((_, __0, _): (TextSize, ast::Expr, TextSize)) -> core::option::Option<ast::Expr> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action356<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> core::option::Option<ast::Expr>
-{
+fn __action356(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Expr> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action357<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> core::option::Option<ast::Expr>
-{
+fn __action357((_, __0, _): (TextSize, ast::Expr, TextSize)) -> core::option::Option<ast::Expr> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action358<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> core::option::Option<ast::Expr>
-{
+fn __action358(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Expr> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action359<
->(
+fn __action359(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, body, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -33439,295 +32741,221 @@ fn __action359<
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, orelse, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::IfExp(
-        ast::ExprIfExp {
-            test: Box::new(test),
-            body: Box::new(body),
-            orelse: Box::new(orelse),
-            range: (location..end_location).into()
-        }
-    )
+) -> ast::Expr {
+    ast::Expr::IfExp(ast::ExprIfExp {
+        test: Box::new(test),
+        body: Box::new(body),
+        orelse: Box::new(orelse),
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action360<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action360((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action361<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action361((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action362<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> alloc::vec::Vec<ast::Expr>
-{
+fn __action362(__lookbehind: &TextSize, __lookahead: &TextSize) -> alloc::vec::Vec<ast::Expr> {
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action363<
->(
+fn __action363(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
-) -> alloc::vec::Vec<ast::Expr>
-{
+) -> alloc::vec::Vec<ast::Expr> {
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action364<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> core::option::Option<token::Tok>
-{
+fn __action364((_, __0, _): (TextSize, token::Tok, TextSize)) -> core::option::Option<token::Tok> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action365<
->(
+fn __action365(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<token::Tok>
-{
+) -> core::option::Option<token::Tok> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action366<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> alloc::vec::Vec<ast::Stmt>
-{
+fn __action366(__lookbehind: &TextSize, __lookahead: &TextSize) -> alloc::vec::Vec<ast::Stmt> {
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action367<
->(
+fn __action367(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
-) -> alloc::vec::Vec<ast::Stmt>
-{
+) -> alloc::vec::Vec<ast::Stmt> {
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action368<
->(
+fn __action368(
     (_, __0, _): (TextSize, ast::Stmt, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action369<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> alloc::vec::Vec<token::Tok>
-{
+fn __action369(__lookbehind: &TextSize, __lookahead: &TextSize) -> alloc::vec::Vec<token::Tok> {
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action370<
->(
+fn __action370(
     (_, v, _): (TextSize, alloc::vec::Vec<token::Tok>, TextSize),
-) -> alloc::vec::Vec<token::Tok>
-{
+) -> alloc::vec::Vec<token::Tok> {
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action371<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> token::Tok
-{
+fn __action371((_, __0, _): (TextSize, token::Tok, TextSize)) -> token::Tok {
     __0
 }
 
-fn __action372<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> TextSize
-{
+fn __action372(__lookbehind: &TextSize, __lookahead: &TextSize) -> TextSize {
     *__lookbehind
 }
 
-fn __action373<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> TextSize
-{
+fn __action373(__lookbehind: &TextSize, __lookahead: &TextSize) -> TextSize {
     *__lookahead
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action374<
->(
-    (_, __0, _): (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<token::Tok>
-{
+fn __action374((_, __0, _): (TextSize, token::Tok, TextSize)) -> alloc::vec::Vec<token::Tok> {
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action375<
->(
+fn __action375(
     (_, v, _): (TextSize, alloc::vec::Vec<token::Tok>, TextSize),
     (_, e, _): (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<token::Tok>
-{
-    { let mut v = v; v.push(e); v }
+) -> alloc::vec::Vec<token::Tok> {
+    {
+        let mut v = v;
+        v.push(e);
+        v
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action376<
->(
-    (_, __0, _): (TextSize, ast::Stmt, TextSize),
-) -> alloc::vec::Vec<ast::Stmt>
-{
+fn __action376((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> alloc::vec::Vec<ast::Stmt> {
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action377<
->(
+fn __action377(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     (_, e, _): (TextSize, ast::Stmt, TextSize),
-) -> alloc::vec::Vec<ast::Stmt>
-{
-    { let mut v = v; v.push(e); v }
+) -> alloc::vec::Vec<ast::Stmt> {
+    {
+        let mut v = v;
+        v.push(e);
+        v
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action378<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<ast::Expr>
-{
+fn __action378((_, __0, _): (TextSize, ast::Expr, TextSize)) -> alloc::vec::Vec<ast::Expr> {
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action379<
->(
+fn __action379(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<ast::Expr>
-{
-    { let mut v = v; v.push(e); v }
+) -> alloc::vec::Vec<ast::Expr> {
+    {
+        let mut v = v;
+        v.push(e);
+        v
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action380<
->(
+fn __action380(
     (_, __0, _): (TextSize, ast::Identifier, TextSize),
-) -> core::option::Option<ast::Identifier>
-{
+) -> core::option::Option<ast::Identifier> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action381<
->(
+fn __action381(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<ast::Identifier>
-{
+) -> core::option::Option<ast::Identifier> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action382<
->(
+fn __action382(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::Identifier, TextSize),
-) -> ast::Identifier
-{
+) -> ast::Identifier {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action383<
->(
+fn __action383(
     (_, __0, _): (TextSize, ast::Pattern, TextSize),
-) -> core::option::Option<ast::Pattern>
-{
+) -> core::option::Option<ast::Pattern> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action384<
->(
+fn __action384(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<ast::Pattern>
-{
+) -> core::option::Option<ast::Pattern> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action385<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> alloc::vec::Vec<ast::Pattern>
-{
+fn __action385(__lookbehind: &TextSize, __lookahead: &TextSize) -> alloc::vec::Vec<ast::Pattern> {
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action386<
->(
+fn __action386(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
-) -> alloc::vec::Vec<ast::Pattern>
-{
+) -> alloc::vec::Vec<ast::Pattern> {
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action387<
->(
+fn __action387(
     (_, __0, _): (TextSize, (TextSize, ast::Expr, ast::Suite), TextSize),
-) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>
-{
+) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)> {
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action388<
->(
-    (_, v, _): (TextSize, alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>, TextSize),
+fn __action388(
+    (_, v, _): (
+        TextSize,
+        alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>,
+        TextSize,
+    ),
     (_, e, _): (TextSize, (TextSize, ast::Expr, ast::Suite), TextSize),
-) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>
-{
-    { let mut v = v; v.push(e); v }
+) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)> {
+    {
+        let mut v = v;
+        v.push(e);
+        v
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action389<
->(
+fn __action389(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, body, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -33735,120 +32963,136 @@ fn __action389<
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, orelse, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::IfExp(
-        ast::ExprIfExp {
-            test: Box::new(test),
-            body: Box::new(body),
-            orelse: Box::new(orelse),
-            range: (location..end_location).into()
-        }
-    )
+) -> ast::Expr {
+    ast::Expr::IfExp(ast::ExprIfExp {
+        test: Box::new(test),
+        body: Box::new(body),
+        orelse: Box::new(orelse),
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action390<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action390((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action391<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action391((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action392<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<ast::Expr>
-{
+fn __action392((_, __0, _): (TextSize, ast::Expr, TextSize)) -> alloc::vec::Vec<ast::Expr> {
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action393<
->(
+fn __action393(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<ast::Expr>
-{
-    { let mut v = v; v.push(e); v }
+) -> alloc::vec::Vec<ast::Expr> {
+    {
+        let mut v = v;
+        v.push(e);
+        v
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action394<
->(
+fn __action394(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Option<Box<ast::Arg>>
-{
+) -> Option<Box<ast::Arg>> {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action395<
->(
+fn __action395(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, kwarg, _): (TextSize, core::option::Option<ast::Arg>, TextSize),
-) -> Option<Box<ast::Arg>>
-{
+) -> Option<Box<ast::Arg>> {
     {
         kwarg.map(Box::new)
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action396<
->(
-    (_, __0, _): (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
-) -> core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>
-{
+fn __action396(
+    (_, __0, _): (
+        TextSize,
+        (
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        ),
+        TextSize,
+    ),
+) -> core::option::Option<(
+    Option<Box<ast::Arg>>,
+    Vec<ast::ArgWithDefault>,
+    Option<Box<ast::Arg>>,
+)> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action397<
->(
+fn __action397(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>
-{
+) -> core::option::Option<(
+    Option<Box<ast::Arg>>,
+    Vec<ast::ArgWithDefault>,
+    Option<Box<ast::Arg>>,
+)> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action398<
->(
+fn __action398(
     (_, _, _): (TextSize, token::Tok, TextSize),
-    (_, __0, _): (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
-) -> (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)
-{
+    (_, __0, _): (
+        TextSize,
+        (
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        ),
+        TextSize,
+    ),
+) -> (
+    Option<Box<ast::Arg>>,
+    Vec<ast::ArgWithDefault>,
+    Option<Box<ast::Arg>>,
+) {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action399<
->(
+fn __action399(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, va, _): (TextSize, core::option::Option<ast::Arg>, TextSize),
     (_, kwonlyargs, _): (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-    (_, kwarg, _): (TextSize, core::option::Option<Option<Box<ast::Arg>>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+    (_, kwarg, _): (
+        TextSize,
+        core::option::Option<Option<Box<ast::Arg>>>,
+        TextSize,
+    ),
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     {
         if va.is_none() && kwonlyargs.is_empty() && kwarg.is_none() {
             Err(LexicalError {
-                error: LexicalErrorType::OtherError("named arguments must follow bare *".to_string()),
+                error: LexicalErrorType::OtherError(
+                    "named arguments must follow bare *".to_string(),
+                ),
                 location,
             })?
         }
@@ -33861,95 +33105,120 @@ fn __action399<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action400<
->(
+fn __action400(
     (_, args, _): (TextSize, Vec<ast::ArgWithDefault>, TextSize),
-) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>)
-{
+) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>) {
     {
         (vec![], args)
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action401<
->(
+fn __action401(
     (_, posonlyargs, _): (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, args, _): (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>)
-{
+) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>) {
     {
         (posonlyargs, args)
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action402<
->(
+fn __action402(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Option<Box<ast::Arg>>
-{
+) -> Option<Box<ast::Arg>> {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action403<
->(
+fn __action403(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, kwarg, _): (TextSize, core::option::Option<ast::Arg>, TextSize),
-) -> Option<Box<ast::Arg>>
-{
+) -> Option<Box<ast::Arg>> {
     {
         kwarg.map(Box::new)
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action404<
->(
-    (_, __0, _): (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
-) -> core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>
-{
+fn __action404(
+    (_, __0, _): (
+        TextSize,
+        (
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        ),
+        TextSize,
+    ),
+) -> core::option::Option<(
+    Option<Box<ast::Arg>>,
+    Vec<ast::ArgWithDefault>,
+    Option<Box<ast::Arg>>,
+)> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action405<
->(
+fn __action405(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>
-{
+) -> core::option::Option<(
+    Option<Box<ast::Arg>>,
+    Vec<ast::ArgWithDefault>,
+    Option<Box<ast::Arg>>,
+)> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action406<
->(
+fn __action406(
     (_, _, _): (TextSize, token::Tok, TextSize),
-    (_, __0, _): (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
-) -> (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)
-{
+    (_, __0, _): (
+        TextSize,
+        (
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        ),
+        TextSize,
+    ),
+) -> (
+    Option<Box<ast::Arg>>,
+    Vec<ast::ArgWithDefault>,
+    Option<Box<ast::Arg>>,
+) {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action407<
->(
+fn __action407(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, va, _): (TextSize, core::option::Option<ast::Arg>, TextSize),
     (_, kwonlyargs, _): (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-    (_, kwarg, _): (TextSize, core::option::Option<Option<Box<ast::Arg>>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+    (_, kwarg, _): (
+        TextSize,
+        core::option::Option<Option<Box<ast::Arg>>>,
+        TextSize,
+    ),
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     {
         if va.is_none() && kwonlyargs.is_empty() && kwarg.is_none() {
             Err(LexicalError {
-                error: LexicalErrorType::OtherError("named arguments must follow bare *".to_string()),
+                error: LexicalErrorType::OtherError(
+                    "named arguments must follow bare *".to_string(),
+                ),
                 location,
             })?
         }
@@ -33962,71 +33231,58 @@ fn __action407<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action408<
->(
+fn __action408(
     (_, args, _): (TextSize, Vec<ast::ArgWithDefault>, TextSize),
-) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>)
-{
+) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>) {
     {
         (vec![], args)
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action409<
->(
+fn __action409(
     (_, posonlyargs, _): (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, args, _): (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>)
-{
+) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>) {
     {
         (posonlyargs, args)
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action410<
->(
+fn __action410(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e1, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::BinOp(
-        ast::ExprBinOp { left: Box::new(e1), op: ast::Operator::BitXor, right: Box::new(e2), range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::BinOp(ast::ExprBinOp {
+        left: Box::new(e1),
+        op: ast::Operator::BitXor,
+        right: Box::new(e2),
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action411<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action411((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action412<
->(
-    (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> Vec<ast::Expr>
-{
+fn __action412((_, e, _): (TextSize, ast::Expr, TextSize)) -> Vec<ast::Expr> {
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action413<
->(
+fn __action413(
     (_, mut v, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> Vec<ast::Expr>
-{
+) -> Vec<ast::Expr> {
     {
         v.push(e);
         v
@@ -34034,239 +33290,265 @@ fn __action413<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action414<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<ast::Expr>
-{
+fn __action414((_, __0, _): (TextSize, ast::Expr, TextSize)) -> alloc::vec::Vec<ast::Expr> {
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action415<
->(
+fn __action415(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<ast::Expr>
-{
-    { let mut v = v; v.push(e); v }
+) -> alloc::vec::Vec<ast::Expr> {
+    {
+        let mut v = v;
+        v.push(e);
+        v
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action416<
->(
+fn __action416(
     (_, __0, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action417<
->(
+fn __action417(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, mut values, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, last, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
         values.push(last);
-        ast::Expr::BoolOp(
-            ast::ExprBoolOp { op: ast::BoolOp::And, values, range: (location..end_location).into() }
-        )
+        ast::Expr::BoolOp(ast::ExprBoolOp {
+            op: ast::BoolOp::And,
+            values,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action418<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action418((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action419<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<ast::Expr>
-{
+fn __action419((_, __0, _): (TextSize, ast::Expr, TextSize)) -> alloc::vec::Vec<ast::Expr> {
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action420<
->(
+fn __action420(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<ast::Expr>
-{
-    { let mut v = v; v.push(e); v }
+) -> alloc::vec::Vec<ast::Expr> {
+    {
+        let mut v = v;
+        v.push(e);
+        v
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action421<
->(
-    (_, __0, _): (TextSize, (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr), TextSize),
-) -> core::option::Option<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
-{
+fn __action421(
+    (_, __0, _): (
+        TextSize,
+        (
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        ),
+        TextSize,
+    ),
+) -> core::option::Option<(
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+)> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action422<
->(
+fn __action422(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
-{
+) -> core::option::Option<(
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+)> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action423<
->(
+fn __action423(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
-{
+) -> alloc::vec::Vec<(
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+)> {
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action424<
->(
-    (_, v, _): (TextSize, alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
-) -> alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
-{
+fn __action424(
+    (_, v, _): (
+        TextSize,
+        alloc::vec::Vec<(
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        )>,
+        TextSize,
+    ),
+) -> alloc::vec::Vec<(
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+)> {
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action425<
->(
-    (_, __0, _): (TextSize, (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr), TextSize),
+fn __action425(
+    (_, __0, _): (
+        TextSize,
+        (
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        ),
+        TextSize,
+    ),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
-{
+) -> (
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+) {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action426<
->(
-    (_, __0, _): (TextSize, (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr), TextSize),
-) -> alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
-{
+fn __action426(
+    (_, __0, _): (
+        TextSize,
+        (
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        ),
+        TextSize,
+    ),
+) -> alloc::vec::Vec<(
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+)> {
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action427<
->(
-    (_, v, _): (TextSize, alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
-    (_, e, _): (TextSize, (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr), TextSize),
-) -> alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
-{
-    { let mut v = v; v.push(e); v }
+fn __action427(
+    (_, v, _): (
+        TextSize,
+        alloc::vec::Vec<(
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        )>,
+        TextSize,
+    ),
+    (_, e, _): (
+        TextSize,
+        (
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        ),
+        TextSize,
+    ),
+) -> alloc::vec::Vec<(
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+)> {
+    {
+        let mut v = v;
+        v.push(e);
+        v
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action428<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<ast::Expr>
-{
+fn __action428((_, __0, _): (TextSize, ast::Expr, TextSize)) -> alloc::vec::Vec<ast::Expr> {
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action429<
->(
+fn __action429(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<ast::Expr>
-{
-    { let mut v = v; v.push(e); v }
+) -> alloc::vec::Vec<ast::Expr> {
+    {
+        let mut v = v;
+        v.push(e);
+        v
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action430<
->(
+fn __action430(
     (_, __0, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action431<
->(
+fn __action431(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::UnaryOp(
-        ast::ExprUnaryOp { operand: Box::new(e), op: ast::UnaryOp::Not, range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::UnaryOp(ast::ExprUnaryOp {
+        operand: Box::new(e),
+        op: ast::UnaryOp::Not,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action432<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action432((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action433<
->(
+fn __action433(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e1, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::BinOp(
-        ast::ExprBinOp { left: Box::new(e1), op: ast::Operator::BitAnd, right: Box::new(e2), range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::BinOp(ast::ExprBinOp {
+        left: Box::new(e1),
+        op: ast::Operator::BitAnd,
+        right: Box::new(e2),
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action434<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action434((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action435<
->(
-    (_, e, _): (TextSize, ast::ArgWithDefault, TextSize),
-) -> Vec<ast::ArgWithDefault>
-{
+fn __action435((_, e, _): (TextSize, ast::ArgWithDefault, TextSize)) -> Vec<ast::ArgWithDefault> {
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action436<
->(
+fn __action436(
     (_, mut v, _): (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::ArgWithDefault, TextSize),
-) -> Vec<ast::ArgWithDefault>
-{
+) -> Vec<ast::ArgWithDefault> {
     {
         v.push(e);
         v
@@ -34274,70 +33556,54 @@ fn __action436<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action437<
->(
+fn __action437(
     (_, __0, _): (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> core::option::Option<Option<Box<ast::Arg>>>
-{
+) -> core::option::Option<Option<Box<ast::Arg>>> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action438<
->(
+fn __action438(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<Option<Box<ast::Arg>>>
-{
+) -> core::option::Option<Option<Box<ast::Arg>>> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action439<
->(
+fn __action439(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> alloc::vec::Vec<ast::ArgWithDefault>
-{
+) -> alloc::vec::Vec<ast::ArgWithDefault> {
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action440<
->(
+fn __action440(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> alloc::vec::Vec<ast::ArgWithDefault>
-{
+) -> alloc::vec::Vec<ast::ArgWithDefault> {
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action441<
->(
+fn __action441(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::ArgWithDefault, TextSize),
-) -> ast::ArgWithDefault
-{
+) -> ast::ArgWithDefault {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action442<
->(
-    (_, i, _): (TextSize, ast::ArgWithDefault, TextSize),
-) -> ast::ArgWithDefault
-{
+fn __action442((_, i, _): (TextSize, ast::ArgWithDefault, TextSize)) -> ast::ArgWithDefault {
     i
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action443<
->(
+fn __action443(
     (_, mut i, _): (TextSize, ast::ArgWithDefault, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> ast::ArgWithDefault
-{
+) -> ast::ArgWithDefault {
     {
         i.default = Some(Box::new(e));
         i
@@ -34345,41 +33611,26 @@ fn __action443<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action444<
->(
-    (_, __0, _): (TextSize, ast::Arg, TextSize),
-) -> core::option::Option<ast::Arg>
-{
+fn __action444((_, __0, _): (TextSize, ast::Arg, TextSize)) -> core::option::Option<ast::Arg> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action445<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> core::option::Option<ast::Arg>
-{
+fn __action445(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Arg> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action446<
->(
-    (_, e, _): (TextSize, ast::ArgWithDefault, TextSize),
-) -> Vec<ast::ArgWithDefault>
-{
+fn __action446((_, e, _): (TextSize, ast::ArgWithDefault, TextSize)) -> Vec<ast::ArgWithDefault> {
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action447<
->(
+fn __action447(
     (_, mut v, _): (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::ArgWithDefault, TextSize),
-) -> Vec<ast::ArgWithDefault>
-{
+) -> Vec<ast::ArgWithDefault> {
     {
         v.push(e);
         v
@@ -34387,70 +33638,54 @@ fn __action447<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action448<
->(
+fn __action448(
     (_, __0, _): (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> core::option::Option<Option<Box<ast::Arg>>>
-{
+) -> core::option::Option<Option<Box<ast::Arg>>> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action449<
->(
+fn __action449(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<Option<Box<ast::Arg>>>
-{
+) -> core::option::Option<Option<Box<ast::Arg>>> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action450<
->(
+fn __action450(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> alloc::vec::Vec<ast::ArgWithDefault>
-{
+) -> alloc::vec::Vec<ast::ArgWithDefault> {
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action451<
->(
+fn __action451(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> alloc::vec::Vec<ast::ArgWithDefault>
-{
+) -> alloc::vec::Vec<ast::ArgWithDefault> {
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action452<
->(
+fn __action452(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::ArgWithDefault, TextSize),
-) -> ast::ArgWithDefault
-{
+) -> ast::ArgWithDefault {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action453<
->(
-    (_, i, _): (TextSize, ast::ArgWithDefault, TextSize),
-) -> ast::ArgWithDefault
-{
+fn __action453((_, i, _): (TextSize, ast::ArgWithDefault, TextSize)) -> ast::ArgWithDefault {
     i
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action454<
->(
+fn __action454(
     (_, mut i, _): (TextSize, ast::ArgWithDefault, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> ast::ArgWithDefault
-{
+) -> ast::ArgWithDefault {
     {
         i.default = Some(Box::new(e));
         i
@@ -34458,632 +33693,561 @@ fn __action454<
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action455<
->(
-    (_, __0, _): (TextSize, ast::Arg, TextSize),
-) -> core::option::Option<ast::Arg>
-{
+fn __action455((_, __0, _): (TextSize, ast::Arg, TextSize)) -> core::option::Option<ast::Arg> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action456<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> core::option::Option<ast::Arg>
-{
+fn __action456(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Arg> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action457<
->(
-    (_, __0, _): (TextSize, ast::Arg, TextSize),
-) -> core::option::Option<ast::Arg>
-{
+fn __action457((_, __0, _): (TextSize, ast::Arg, TextSize)) -> core::option::Option<ast::Arg> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action458<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> core::option::Option<ast::Arg>
-{
+fn __action458(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Arg> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action459<
->(
+fn __action459(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, mut values, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, last, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
         values.push(last);
-        ast::Expr::BoolOp(
-            ast::ExprBoolOp { op: ast::BoolOp::Or, values, range: (location..end_location).into() }
-        )
+        ast::Expr::BoolOp(ast::ExprBoolOp {
+            op: ast::BoolOp::Or,
+            values,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action460<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action460((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action461<
->(
+fn __action461(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, mut values, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, last, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
         values.push(last);
-        ast::Expr::BoolOp(
-            ast::ExprBoolOp { op: ast::BoolOp::And, values, range: (location..end_location).into() }
-        )
+        ast::Expr::BoolOp(ast::ExprBoolOp {
+            op: ast::BoolOp::And,
+            values,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action462<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action462((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action463<
->(
+fn __action463(
     (_, __0, _): (TextSize, ast::ArgWithDefault, TextSize),
-) -> alloc::vec::Vec<ast::ArgWithDefault>
-{
+) -> alloc::vec::Vec<ast::ArgWithDefault> {
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action464<
->(
+fn __action464(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     (_, e, _): (TextSize, ast::ArgWithDefault, TextSize),
-) -> alloc::vec::Vec<ast::ArgWithDefault>
-{
-    { let mut v = v; v.push(e); v }
+) -> alloc::vec::Vec<ast::ArgWithDefault> {
+    {
+        let mut v = v;
+        v.push(e);
+        v
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action465<
->(
+fn __action465(
     (_, __0, _): (TextSize, ast::ArgWithDefault, TextSize),
-) -> alloc::vec::Vec<ast::ArgWithDefault>
-{
+) -> alloc::vec::Vec<ast::ArgWithDefault> {
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action466<
->(
+fn __action466(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     (_, e, _): (TextSize, ast::ArgWithDefault, TextSize),
-) -> alloc::vec::Vec<ast::ArgWithDefault>
-{
-    { let mut v = v; v.push(e); v }
+) -> alloc::vec::Vec<ast::ArgWithDefault> {
+    {
+        let mut v = v;
+        v.push(e);
+        v
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action467<
->(
+fn __action467(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e1, _): (TextSize, ast::Expr, TextSize),
     (_, op, _): (TextSize, ast::Operator, TextSize),
     (_, e2, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::BinOp(
-        ast::ExprBinOp { left: Box::new(e1), op, right: Box::new(e2), range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::BinOp(ast::ExprBinOp {
+        left: Box::new(e1),
+        op,
+        right: Box::new(e2),
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action468<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action468((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action469<
->(
+fn __action469(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, left, _): (TextSize, ast::Expr, TextSize),
     (_, comparisons, _): (TextSize, alloc::vec::Vec<(ast::CmpOp, ast::Expr)>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
         let (ops, comparators) = comparisons.into_iter().unzip();
-        ast::Expr::Compare(
-            ast::ExprCompare { left: Box::new(left), ops, comparators, range: (location..end_location).into() }
-        )
+        ast::Expr::Compare(ast::ExprCompare {
+            left: Box::new(left),
+            ops,
+            comparators,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action470<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action470((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action471<
->(
+fn __action471(
     (_, __0, _): (TextSize, (ast::CmpOp, ast::Expr), TextSize),
-) -> alloc::vec::Vec<(ast::CmpOp, ast::Expr)>
-{
+) -> alloc::vec::Vec<(ast::CmpOp, ast::Expr)> {
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action472<
->(
+fn __action472(
     (_, v, _): (TextSize, alloc::vec::Vec<(ast::CmpOp, ast::Expr)>, TextSize),
     (_, e, _): (TextSize, (ast::CmpOp, ast::Expr), TextSize),
-) -> alloc::vec::Vec<(ast::CmpOp, ast::Expr)>
-{
-    { let mut v = v; v.push(e); v }
+) -> alloc::vec::Vec<(ast::CmpOp, ast::Expr)> {
+    {
+        let mut v = v;
+        v.push(e);
+        v
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action473<
->(
+fn __action473(
     (_, __0, _): (TextSize, ast::CmpOp, TextSize),
     (_, __1, _): (TextSize, ast::Expr, TextSize),
-) -> (ast::CmpOp, ast::Expr)
-{
+) -> (ast::CmpOp, ast::Expr) {
     (__0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action474<
->(
+fn __action474(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, a, _): (TextSize, ast::Expr, TextSize),
     (_, op, _): (TextSize, ast::Operator, TextSize),
     (_, b, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::BinOp(
-        ast::ExprBinOp { left: Box::new(a), op, right: Box::new(b), range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::BinOp(ast::ExprBinOp {
+        left: Box::new(a),
+        op,
+        right: Box::new(b),
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action475<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action475((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action476<
->(
+fn __action476(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::UnaryOp(
-        ast::ExprUnaryOp { operand: Box::new(e), op: ast::UnaryOp::Not, range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::UnaryOp(ast::ExprUnaryOp {
+        operand: Box::new(e),
+        op: ast::UnaryOp::Not,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action477<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action477((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action478<
->(
+fn __action478(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, left, _): (TextSize, ast::Expr, TextSize),
     (_, comparisons, _): (TextSize, alloc::vec::Vec<(ast::CmpOp, ast::Expr)>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
         let (ops, comparators) = comparisons.into_iter().unzip();
-        ast::Expr::Compare(
-            ast::ExprCompare { left: Box::new(left), ops, comparators, range: (location..end_location).into() }
-        )
+        ast::Expr::Compare(ast::ExprCompare {
+            left: Box::new(left),
+            ops,
+            comparators,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action479<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action479((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action480<
->(
+fn __action480(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, a, _): (TextSize, ast::Expr, TextSize),
     (_, op, _): (TextSize, ast::Operator, TextSize),
     (_, b, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::BinOp(
-        ast::ExprBinOp { left: Box::new(a), op, right: Box::new(b), range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::BinOp(ast::ExprBinOp {
+        left: Box::new(a),
+        op,
+        right: Box::new(b),
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action481<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action481((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action482<
->(
+fn __action482(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, op, _): (TextSize, ast::UnaryOp, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::UnaryOp(
-        ast::ExprUnaryOp { operand: Box::new(e), op, range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::UnaryOp(ast::ExprUnaryOp {
+        operand: Box::new(e),
+        op,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action483<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action483((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action484<
->(
+fn __action484(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e1, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::BinOp(
-        ast::ExprBinOp { left: Box::new(e1), op: ast::Operator::BitOr, right: Box::new(e2), range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::BinOp(ast::ExprBinOp {
+        left: Box::new(e1),
+        op: ast::Operator::BitOr,
+        right: Box::new(e2),
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action485<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action485((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action486<
->(
+fn __action486(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e1, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::BinOp(
-        ast::ExprBinOp { left: Box::new(e1), op: ast::Operator::BitXor, right: Box::new(e2), range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::BinOp(ast::ExprBinOp {
+        left: Box::new(e1),
+        op: ast::Operator::BitXor,
+        right: Box::new(e2),
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action487<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action487((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action488<
->(
+fn __action488(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, b, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::BinOp(
-        ast::ExprBinOp { left: Box::new(e), op: ast::Operator::Pow, right: Box::new(b), range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::BinOp(ast::ExprBinOp {
+        left: Box::new(e),
+        op: ast::Operator::Pow,
+        right: Box::new(b),
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action489<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action489((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action490<
->(
+fn __action490(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, atom, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
-        ast::Expr::Await(
-            ast::ExprAwait { value: Box::new(atom), range: (location..end_location).into() }
-        )
+        ast::Expr::Await(ast::ExprAwait {
+            value: Box::new(atom),
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action491<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action491((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action492<
->(
+fn __action492(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e1, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::BinOp(
-        ast::ExprBinOp { left: Box::new(e1), op: ast::Operator::BitAnd, right: Box::new(e2), range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::BinOp(ast::ExprBinOp {
+        left: Box::new(e1),
+        op: ast::Operator::BitAnd,
+        right: Box::new(e2),
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action493<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action493((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action494<
->(
+fn __action494(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e1, _): (TextSize, ast::Expr, TextSize),
     (_, op, _): (TextSize, ast::Operator, TextSize),
     (_, e2, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::BinOp(
-        ast::ExprBinOp { left: Box::new(e1), op, right: Box::new(e2), range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::BinOp(ast::ExprBinOp {
+        left: Box::new(e1),
+        op,
+        right: Box::new(e2),
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action495<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action495((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action496<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action496((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action497<
->(
+fn __action497(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, f, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, a, _): (TextSize, ArgumentList, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
-        ast::Expr::Call(
-            ast::ExprCall { func: Box::new(f), args: a.args, keywords: a.keywords, range: (location..end_location).into() }
-        )
+        ast::Expr::Call(ast::ExprCall {
+            func: Box::new(f),
+            args: a.args,
+            keywords: a.keywords,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action498<
->(
+fn __action498(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, s, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Subscript(
-        ast::ExprSubscript { value: Box::new(e), slice: Box::new(s), ctx: ast::ExprContext::Load, range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::Subscript(ast::ExprSubscript {
+        value: Box::new(e),
+        slice: Box::new(s),
+        ctx: ast::ExprContext::Load,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action499<
->(
+fn __action499(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, attr, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Attribute(
-        ast::ExprAttribute { value: Box::new(e), attr, ctx: ast::ExprContext::Load, range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::Attribute(ast::ExprAttribute {
+        value: Box::new(e),
+        attr,
+        ctx: ast::ExprContext::Load,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action500<
->(
+fn __action500(
     (_, location, _): (TextSize, TextSize, TextSize),
-    (_, s, _): (TextSize, alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+    (_, s, _): (
+        TextSize,
+        alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>,
+        TextSize,
+    ),
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     Ok(parse_strings(s)?)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action501<
->(
+fn __action501(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, value, _): (TextSize, ast::Constant, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Constant(
-        ast::ExprConstant { value, kind: None, range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::Constant(ast::ExprConstant {
+        value,
+        kind: None,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action502<
->(
+fn __action502(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, name, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Name(
-        ast::ExprName { id: name, ctx: ast::ExprContext::Load, range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::Name(ast::ExprName {
+        id: name,
+        ctx: ast::ExprContext::Load,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action503<
->(
+fn __action503(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
         let elts = e.unwrap_or_default();
-        ast::Expr::List(
-            ast::ExprList { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() }
-        )
+        ast::Expr::List(ast::ExprList {
+            elts,
+            ctx: ast::ExprContext::Load,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action504<
->(
+fn __action504(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, elt, _): (TextSize, ast::Expr, TextSize),
     (_, generators, _): (TextSize, Vec<ast::Comprehension>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
-        ast::Expr::ListComp(
-            ast::ExprListComp { elt: Box::new(elt), generators, range: (location..end_location).into() }
-        )
+        ast::Expr::ListComp(ast::ExprListComp {
+            elt: Box::new(elt),
+            generators,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action505<
->(
+fn __action505(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, elts, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, trailing_comma, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
         if elts.len() == 1 && trailing_comma.is_none() {
             elts.into_iter().next().unwrap()
         } else {
-            ast::Expr::Tuple(
-                ast::ExprTuple { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() }
-            )
+            ast::Expr::Tuple(ast::ExprTuple {
+                elts,
+                ctx: ast::ExprContext::Load,
+                range: (location..end_location).into(),
+            })
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action506<
->(
+fn __action506(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, left, _): (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
@@ -35092,578 +34256,549 @@ fn __action506<
     (_, trailing_comma, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     {
         if left.is_none() && right.is_empty() && trailing_comma.is_none() {
             if mid.is_starred_expr() {
-                Err(LexicalError{
-                    error: LexicalErrorType::OtherError("cannot use starred expression here".to_string()),
+                Err(LexicalError {
+                    error: LexicalErrorType::OtherError(
+                        "cannot use starred expression here".to_string(),
+                    ),
                     location: mid.start(),
                 })?
             }
             Ok(mid)
         } else {
-            let elts = left.into_iter().flatten().chain([mid]).chain(right).collect();
-            Ok(ast::Expr::Tuple(
-                ast::ExprTuple { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() },
-            ))
+            let elts = left
+                .into_iter()
+                .flatten()
+                .chain([mid])
+                .chain(right)
+                .collect();
+            Ok(ast::Expr::Tuple(ast::ExprTuple {
+                elts,
+                ctx: ast::ExprContext::Load,
+                range: (location..end_location).into(),
+            }))
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action507<
->(
+fn __action507(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Tuple(
-        ast::ExprTuple { elts: Vec::new(), ctx: ast::ExprContext::Load, range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::Tuple(ast::ExprTuple {
+        elts: Vec::new(),
+        ctx: ast::ExprContext::Load,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action508<
->(
+fn __action508(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     e
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action509<
->(
+fn __action509(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, elt, _): (TextSize, ast::Expr, TextSize),
     (_, generators, _): (TextSize, Vec<ast::Comprehension>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
-        ast::Expr::GeneratorExp(
-            ast::ExprGeneratorExp { elt: Box::new(elt), generators, range: (location..end_location).into() }
-        )
+        ast::Expr::GeneratorExp(ast::ExprGeneratorExp {
+            elt: Box::new(elt),
+            generators,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action510<
->(
+fn __action510(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     {
-        Err(LexicalError{
-            error : LexicalErrorType::OtherError("cannot use double starred expression here".to_string()),
+        Err(LexicalError {
+            error: LexicalErrorType::OtherError(
+                "cannot use double starred expression here".to_string(),
+            ),
             location,
-        }.into())
+        }
+        .into())
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action511<
->(
+fn __action511(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-    (_, e, _): (TextSize, core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>, TextSize),
+    (_, e, _): (
+        TextSize,
+        core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>,
+        TextSize,
+    ),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
         let (keys, values) = e
             .unwrap_or_default()
             .into_iter()
             .map(|(k, v)| (k.map(|x| *x), v))
             .unzip();
-        ast::Expr::Dict(
-            ast::ExprDict { keys, values, range: (location..end_location).into() }
-        )
+        ast::Expr::Dict(ast::ExprDict {
+            keys,
+            values,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action512<
->(
+fn __action512(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e1, _): (TextSize, (ast::Expr, ast::Expr), TextSize),
     (_, generators, _): (TextSize, Vec<ast::Comprehension>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
-        ast::Expr::DictComp(
-            ast::ExprDictComp {
-                key: Box::new(e1.0),
-                value: Box::new(e1.1),
-                generators,
-                range: (location..end_location).into()
-            }
-        )
+        ast::Expr::DictComp(ast::ExprDictComp {
+            key: Box::new(e1.0),
+            value: Box::new(e1.1),
+            generators,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action513<
->(
+fn __action513(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, elts, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Set(
-        ast::ExprSet { elts, range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::Set(ast::ExprSet {
+        elts,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action514<
->(
+fn __action514(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, elt, _): (TextSize, ast::Expr, TextSize),
     (_, generators, _): (TextSize, Vec<ast::Comprehension>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
-        ast::Expr::SetComp(
-            ast::ExprSetComp { elt: Box::new(elt), generators, range: (location..end_location).into() }
-        )
+        ast::Expr::SetComp(ast::ExprSetComp {
+            elt: Box::new(elt),
+            generators,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action515<
->(
+fn __action515(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Constant(ast::ExprConstant { value: true.into(), kind: None, range: (location..end_location).into() })
+) -> ast::Expr {
+    ast::Expr::Constant(ast::ExprConstant {
+        value: true.into(),
+        kind: None,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action516<
->(
+fn __action516(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Constant(ast::ExprConstant { value: false.into(), kind: None, range: (location..end_location).into() })
+) -> ast::Expr {
+    ast::Expr::Constant(ast::ExprConstant {
+        value: false.into(),
+        kind: None,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action517<
->(
+fn __action517(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Constant(ast::ExprConstant { value: ast::Constant::None, kind: None, range: (location..end_location).into() })
+) -> ast::Expr {
+    ast::Expr::Constant(ast::ExprConstant {
+        value: ast::Constant::None,
+        kind: None,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action518<
->(
+fn __action518(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Constant(ast::ExprConstant { value: ast::Constant::Ellipsis, kind: None, range: (location..end_location).into() })
+) -> ast::Expr {
+    ast::Expr::Constant(ast::ExprConstant {
+        value: ast::Constant::Ellipsis,
+        kind: None,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action519<
->(
+fn __action519(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, a, _): (TextSize, ast::Expr, TextSize),
     (_, op, _): (TextSize, ast::Operator, TextSize),
     (_, b, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::BinOp(
-        ast::ExprBinOp { left: Box::new(a), op, right: Box::new(b), range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::BinOp(ast::ExprBinOp {
+        left: Box::new(a),
+        op,
+        right: Box::new(b),
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action520<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action520((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action521<
->(
+fn __action521(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, a, _): (TextSize, ast::Expr, TextSize),
     (_, op, _): (TextSize, ast::Operator, TextSize),
     (_, b, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::BinOp(
-        ast::ExprBinOp { left: Box::new(a), op, right: Box::new(b), range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::BinOp(ast::ExprBinOp {
+        left: Box::new(a),
+        op,
+        right: Box::new(b),
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action522<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action522((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action523<
->(
+fn __action523(
     (_, __0, _): (TextSize, Vec<(Option<Box<ast::Expr>>, ast::Expr)>, TextSize),
-) -> core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>
-{
+) -> core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action524<
->(
+fn __action524(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>
-{
+) -> core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action525<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> alloc::vec::Vec<ast::Expr>
-{
+fn __action525(__lookbehind: &TextSize, __lookahead: &TextSize) -> alloc::vec::Vec<ast::Expr> {
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action526<
->(
+fn __action526(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
-) -> alloc::vec::Vec<ast::Expr>
-{
+) -> alloc::vec::Vec<ast::Expr> {
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action527<
->(
+fn __action527(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action528<
->(
+fn __action528(
     (_, __0, _): (TextSize, Vec<ast::Expr>, TextSize),
-) -> core::option::Option<Vec<ast::Expr>>
-{
+) -> core::option::Option<Vec<ast::Expr>> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action529<
->(
+fn __action529(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<Vec<ast::Expr>>
-{
+) -> core::option::Option<Vec<ast::Expr>> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action530<
->(
+fn __action530(
     (_, __0, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Expr>
-{
+) -> Vec<ast::Expr> {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action531<
->(
+fn __action531(
     (_, __0, _): (TextSize, Vec<ast::Expr>, TextSize),
-) -> core::option::Option<Vec<ast::Expr>>
-{
+) -> core::option::Option<Vec<ast::Expr>> {
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action532<
->(
+fn __action532(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<Vec<ast::Expr>>
-{
+) -> core::option::Option<Vec<ast::Expr>> {
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action533<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<ast::Expr>
-{
+fn __action533((_, __0, _): (TextSize, ast::Expr, TextSize)) -> alloc::vec::Vec<ast::Expr> {
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action534<
->(
+fn __action534(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<ast::Expr>
-{
-    { let mut v = v; v.push(e); v }
+) -> alloc::vec::Vec<ast::Expr> {
+    {
+        let mut v = v;
+        v.push(e);
+        v
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action535<
->(
+fn __action535(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, op, _): (TextSize, ast::UnaryOp, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::UnaryOp(
-        ast::ExprUnaryOp { operand: Box::new(e), op, range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::UnaryOp(ast::ExprUnaryOp {
+        operand: Box::new(e),
+        op,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action536<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action536((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action537<
->(
+fn __action537(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, b, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::BinOp(
-        ast::ExprBinOp { left: Box::new(e), op: ast::Operator::Pow, right: Box::new(b), range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::BinOp(ast::ExprBinOp {
+        left: Box::new(e),
+        op: ast::Operator::Pow,
+        right: Box::new(b),
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action538<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action538((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action539<
->(
+fn __action539(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, atom, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
-        ast::Expr::Await(
-            ast::ExprAwait { value: Box::new(atom), range: (location..end_location).into() }
-        )
+        ast::Expr::Await(ast::ExprAwait {
+            value: Box::new(atom),
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action540<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action540((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action541<
->(
-    (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action541((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action542<
->(
+fn __action542(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, f, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, a, _): (TextSize, ArgumentList, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
-        ast::Expr::Call(
-            ast::ExprCall { func: Box::new(f), args: a.args, keywords: a.keywords, range: (location..end_location).into() }
-        )
+        ast::Expr::Call(ast::ExprCall {
+            func: Box::new(f),
+            args: a.args,
+            keywords: a.keywords,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action543<
->(
+fn __action543(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, s, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Subscript(
-        ast::ExprSubscript { value: Box::new(e), slice: Box::new(s), ctx: ast::ExprContext::Load, range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::Subscript(ast::ExprSubscript {
+        value: Box::new(e),
+        slice: Box::new(s),
+        ctx: ast::ExprContext::Load,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action544<
->(
+fn __action544(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, attr, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Attribute(
-        ast::ExprAttribute { value: Box::new(e), attr, ctx: ast::ExprContext::Load, range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::Attribute(ast::ExprAttribute {
+        value: Box::new(e),
+        attr,
+        ctx: ast::ExprContext::Load,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action545<
->(
+fn __action545(
     (_, location, _): (TextSize, TextSize, TextSize),
-    (_, s, _): (TextSize, alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+    (_, s, _): (
+        TextSize,
+        alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>,
+        TextSize,
+    ),
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     Ok(parse_strings(s)?)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action546<
->(
+fn __action546(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, value, _): (TextSize, ast::Constant, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Constant(
-        ast::ExprConstant { value, kind: None, range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::Constant(ast::ExprConstant {
+        value,
+        kind: None,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action547<
->(
+fn __action547(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, name, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Name(
-        ast::ExprName { id: name, ctx: ast::ExprContext::Load, range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::Name(ast::ExprName {
+        id: name,
+        ctx: ast::ExprContext::Load,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action548<
->(
+fn __action548(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
         let elts = e.unwrap_or_default();
-        ast::Expr::List(
-            ast::ExprList { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() }
-        )
+        ast::Expr::List(ast::ExprList {
+            elts,
+            ctx: ast::ExprContext::Load,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action549<
->(
+fn __action549(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, elt, _): (TextSize, ast::Expr, TextSize),
     (_, generators, _): (TextSize, Vec<ast::Comprehension>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
-        ast::Expr::ListComp(
-            ast::ExprListComp { elt: Box::new(elt), generators, range: (location..end_location).into() }
-        )
+        ast::Expr::ListComp(ast::ExprListComp {
+            elt: Box::new(elt),
+            generators,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action550<
->(
+fn __action550(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, left, _): (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
@@ -35672,267 +34807,257 @@ fn __action550<
     (_, trailing_comma, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     {
         if left.is_none() && right.is_empty() && trailing_comma.is_none() {
             if mid.is_starred_expr() {
-                Err(LexicalError{
-                    error: LexicalErrorType::OtherError("cannot use starred expression here".to_string()),
+                Err(LexicalError {
+                    error: LexicalErrorType::OtherError(
+                        "cannot use starred expression here".to_string(),
+                    ),
                     location: mid.start(),
                 })?
             }
             Ok(mid)
         } else {
-            let elts = left.into_iter().flatten().chain([mid]).chain(right).collect();
-            Ok(ast::Expr::Tuple(
-                ast::ExprTuple { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() },
-            ))
+            let elts = left
+                .into_iter()
+                .flatten()
+                .chain([mid])
+                .chain(right)
+                .collect();
+            Ok(ast::Expr::Tuple(ast::ExprTuple {
+                elts,
+                ctx: ast::ExprContext::Load,
+                range: (location..end_location).into(),
+            }))
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action551<
->(
+fn __action551(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Tuple(
-        ast::ExprTuple { elts: Vec::new(), ctx: ast::ExprContext::Load, range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::Tuple(ast::ExprTuple {
+        elts: Vec::new(),
+        ctx: ast::ExprContext::Load,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action552<
->(
+fn __action552(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     e
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action553<
->(
+fn __action553(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, elt, _): (TextSize, ast::Expr, TextSize),
     (_, generators, _): (TextSize, Vec<ast::Comprehension>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
-        ast::Expr::GeneratorExp(
-            ast::ExprGeneratorExp { elt: Box::new(elt), generators, range: (location..end_location).into() }
-        )
+        ast::Expr::GeneratorExp(ast::ExprGeneratorExp {
+            elt: Box::new(elt),
+            generators,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action554<
->(
+fn __action554(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     {
-        Err(LexicalError{
-            error : LexicalErrorType::OtherError("cannot use double starred expression here".to_string()),
+        Err(LexicalError {
+            error: LexicalErrorType::OtherError(
+                "cannot use double starred expression here".to_string(),
+            ),
             location,
-        }.into())
+        }
+        .into())
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action555<
->(
+fn __action555(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-    (_, e, _): (TextSize, core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>, TextSize),
+    (_, e, _): (
+        TextSize,
+        core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>,
+        TextSize,
+    ),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
         let (keys, values) = e
             .unwrap_or_default()
             .into_iter()
             .map(|(k, v)| (k.map(|x| *x), v))
             .unzip();
-        ast::Expr::Dict(
-            ast::ExprDict { keys, values, range: (location..end_location).into() }
-        )
+        ast::Expr::Dict(ast::ExprDict {
+            keys,
+            values,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action556<
->(
+fn __action556(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e1, _): (TextSize, (ast::Expr, ast::Expr), TextSize),
     (_, generators, _): (TextSize, Vec<ast::Comprehension>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
-        ast::Expr::DictComp(
-            ast::ExprDictComp {
-                key: Box::new(e1.0),
-                value: Box::new(e1.1),
-                generators,
-                range: (location..end_location).into()
-            }
-        )
+        ast::Expr::DictComp(ast::ExprDictComp {
+            key: Box::new(e1.0),
+            value: Box::new(e1.1),
+            generators,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action557<
->(
+fn __action557(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, elts, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Set(
-        ast::ExprSet { elts, range: (location..end_location).into() }
-    )
+) -> ast::Expr {
+    ast::Expr::Set(ast::ExprSet {
+        elts,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action558<
->(
+fn __action558(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, elt, _): (TextSize, ast::Expr, TextSize),
     (_, generators, _): (TextSize, Vec<ast::Comprehension>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     {
-        ast::Expr::SetComp(
-            ast::ExprSetComp { elt: Box::new(elt), generators, range: (location..end_location).into() }
-        )
+        ast::Expr::SetComp(ast::ExprSetComp {
+            elt: Box::new(elt),
+            generators,
+            range: (location..end_location).into(),
+        })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action559<
->(
+fn __action559(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Constant(ast::ExprConstant { value: true.into(), kind: None, range: (location..end_location).into() })
+) -> ast::Expr {
+    ast::Expr::Constant(ast::ExprConstant {
+        value: true.into(),
+        kind: None,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action560<
->(
+fn __action560(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Constant(ast::ExprConstant { value: false.into(), kind: None, range: (location..end_location).into() })
+) -> ast::Expr {
+    ast::Expr::Constant(ast::ExprConstant {
+        value: false.into(),
+        kind: None,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action561<
->(
+fn __action561(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Constant(ast::ExprConstant { value: ast::Constant::None, kind: None, range: (location..end_location).into() })
+) -> ast::Expr {
+    ast::Expr::Constant(ast::ExprConstant {
+        value: ast::Constant::None,
+        kind: None,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action562<
->(
+fn __action562(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
-    ast::Expr::Constant(ast::ExprConstant { value: ast::Constant::Ellipsis, kind: None, range: (location..end_location).into() })
+) -> ast::Expr {
+    ast::Expr::Constant(ast::ExprConstant {
+        value: ast::Constant::Ellipsis,
+        kind: None,
+        range: (location..end_location).into(),
+    })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action563<
->(
+fn __action563(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Expr>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action340(
-        __3,
-    );
+    let __temp0 = __action340(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action505(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action505(__0, __1, __2, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action564<
->(
+fn __action564(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Expr>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action505(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __3,
-        __4,
-    )
+    __action505(__0, __1, __2, __temp0, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action565<
->(
+fn __action565(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
@@ -35941,29 +35066,16 @@ fn __action565<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __5.0;
     let __end0 = __5.2;
-    let __temp0 = __action340(
-        __5,
-    );
+    let __temp0 = __action340(__5);
     let __temp0 = (__start0, __temp0, __end0);
-    __action506(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-        __6,
-        __7,
-    )
+    __action506(__0, __1, __2, __3, __4, __temp0, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action566<
->(
+fn __action566(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
@@ -35971,30 +35083,16 @@ fn __action566<
     __4: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __4.2;
     let __end0 = __5.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action506(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-        __5,
-        __6,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action567<
->(
+    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action506(__0, __1, __2, __3, __4, __temp0, __5, __6)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action567(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
@@ -36003,29 +35101,16 @@ fn __action567<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __5.0;
     let __end0 = __5.2;
-    let __temp0 = __action340(
-        __5,
-    );
+    let __temp0 = __action340(__5);
     let __temp0 = (__start0, __temp0, __end0);
-    __action550(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-        __6,
-        __7,
-    )
+    __action550(__0, __1, __2, __3, __4, __temp0, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action568<
->(
+fn __action568(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
@@ -36033,30 +35118,16 @@ fn __action568<
     __4: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __4.2;
     let __end0 = __5.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action550(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-        __5,
-        __6,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action569<
->(
+    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action550(__0, __1, __2, __3, __4, __temp0, __5, __6)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action569(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -36066,30 +35137,16 @@ fn __action569<
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __6.0;
     let __end0 = __6.2;
-    let __temp0 = __action340(
-        __6,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action133(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-        __7,
-        __8,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action570<
->(
+    let __temp0 = __action340(__6);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action133(__0, __1, __2, __3, __4, __5, __temp0, __7, __8)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action570(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -36098,31 +35155,16 @@ fn __action570<
     __5: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __5.2;
     let __end0 = __6.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action133(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-        __6,
-        __7,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action571<
->(
+    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action133(__0, __1, __2, __3, __4, __5, __temp0, __6, __7)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action571(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -36130,57 +35172,32 @@ fn __action571<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action340(
-        __4,
-    );
+    let __temp0 = __action340(__4);
     let __temp0 = (__start0, __temp0, __end0);
-    __action134(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __5,
-        __6,
-    )
+    __action134(__0, __1, __2, __3, __temp0, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action572<
->(
+fn __action572(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Vec<ast::Pattern>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action134(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action134(__0, __1, __2, __3, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action573<
->(
+fn __action573(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -36188,57 +35205,32 @@ fn __action573<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action340(
-        __4,
-    );
+    let __temp0 = __action340(__4);
     let __temp0 = (__start0, __temp0, __end0);
-    __action135(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __5,
-        __6,
-    )
+    __action135(__0, __1, __2, __3, __temp0, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action574<
->(
+fn __action574(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action135(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action135(__0, __1, __2, __3, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action575<
->(
+fn __action575(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -36248,30 +35240,16 @@ fn __action575<
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __6.0;
     let __end0 = __6.2;
-    let __temp0 = __action340(
-        __6,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action137(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-        __7,
-        __8,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action576<
->(
+    let __temp0 = __action340(__6);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action137(__0, __1, __2, __3, __4, __5, __temp0, __7, __8)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action576(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -36280,31 +35258,16 @@ fn __action576<
     __5: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __5.2;
     let __end0 = __6.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action137(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-        __6,
-        __7,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action577<
->(
+    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action137(__0, __1, __2, __3, __4, __5, __temp0, __6, __7)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action577(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -36312,57 +35275,32 @@ fn __action577<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action340(
-        __4,
-    );
+    let __temp0 = __action340(__4);
     let __temp0 = (__start0, __temp0, __end0);
-    __action138(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __5,
-        __6,
-    )
+    __action138(__0, __1, __2, __3, __temp0, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action578<
->(
+fn __action578(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Vec<ast::Pattern>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action138(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action138(__0, __1, __2, __3, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action579<
->(
+fn __action579(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -36370,371 +35308,213 @@ fn __action579<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action340(
-        __4,
-    );
+    let __temp0 = __action340(__4);
     let __temp0 = (__start0, __temp0, __end0);
-    __action139(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __5,
-        __6,
-    )
+    __action139(__0, __1, __2, __3, __temp0, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action580<
->(
+fn __action580(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action139(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action139(__0, __1, __2, __3, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action581<
->(
+fn __action581(
     __0: (TextSize, Vec<(Option<Box<ast::Expr>>, ast::Expr)>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Vec<(Option<Box<ast::Expr>>, ast::Expr)>
-{
+) -> Vec<(Option<Box<ast::Expr>>, ast::Expr)> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action340(
-        __1,
-    );
+    let __temp0 = __action340(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action201(
-        __0,
-        __temp0,
-    )
+    __action201(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action582<
->(
+fn __action582(
     __0: (TextSize, Vec<(Option<Box<ast::Expr>>, ast::Expr)>, TextSize),
-) -> Vec<(Option<Box<ast::Expr>>, ast::Expr)>
-{
+) -> Vec<(Option<Box<ast::Expr>>, ast::Expr)> {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action201(
-        __0,
-        __temp0,
-    )
+    __action201(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action583<
->(
+fn __action583(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Expr>
-{
+) -> Vec<ast::Expr> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action340(
-        __1,
-    );
+    let __temp0 = __action340(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action209(
-        __0,
-        __temp0,
-    )
+    __action209(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action584<
->(
-    __0: (TextSize, Vec<ast::Expr>, TextSize),
-) -> Vec<ast::Expr>
-{
+fn __action584(__0: (TextSize, Vec<ast::Expr>, TextSize)) -> Vec<ast::Expr> {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action209(
-        __0,
-        __temp0,
-    )
+    __action209(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action585<
->(
+fn __action585(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action340(
-        __2,
-    );
+    let __temp0 = __action340(__2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action237(
-        __0,
-        __1,
-        __temp0,
-        __3,
-    )
+    __action237(__0, __1, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action586<
->(
+fn __action586(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action237(
-        __0,
-        __1,
-        __temp0,
-        __2,
-    )
+    __action237(__0, __1, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action587<
->(
+fn __action587(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action340(
-        __2,
-    );
+    let __temp0 = __action340(__2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action234(
-        __0,
-        __1,
-        __temp0,
-        __3,
-    )
+    __action234(__0, __1, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action588<
->(
+fn __action588(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action234(
-        __0,
-        __1,
-        __temp0,
-        __2,
-    )
+    __action234(__0, __1, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action589<
->(
+fn __action589(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Alias>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Vec<ast::Alias>
-{
+) -> Vec<ast::Alias> {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action340(
-        __3,
-    );
+    let __temp0 = __action340(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action64(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action64(__0, __1, __2, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action590<
->(
+fn __action590(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Alias>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Vec<ast::Alias>
-{
+) -> Vec<ast::Alias> {
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action64(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __3,
-        __4,
-    )
+    __action64(__0, __1, __2, __temp0, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action591<
->(
+fn __action591(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Expr>
-{
+) -> Vec<ast::Expr> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action340(
-        __1,
-    );
+    let __temp0 = __action340(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action200(
-        __0,
-        __temp0,
-    )
+    __action200(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action592<
->(
-    __0: (TextSize, Vec<ast::Expr>, TextSize),
-) -> Vec<ast::Expr>
-{
+fn __action592(__0: (TextSize, Vec<ast::Expr>, TextSize)) -> Vec<ast::Expr> {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action200(
-        __0,
-        __temp0,
-    )
+    __action200(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action593<
->(
+fn __action593(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action340(
-        __3,
-    );
+    let __temp0 = __action340(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action129(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action129(__0, __1, __2, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action594<
->(
+fn __action594(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action129(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __3,
-        __4,
-    )
+    __action129(__0, __1, __2, __temp0, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action595<
->(
+fn __action595(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -36742,57 +35522,32 @@ fn __action595<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action340(
-        __4,
-    );
+    let __temp0 = __action340(__4);
     let __temp0 = (__start0, __temp0, __end0);
-    __action130(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __5,
-        __6,
-    )
+    __action130(__0, __1, __2, __3, __temp0, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action596<
->(
+fn __action596(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Identifier, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action130(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action130(__0, __1, __2, __3, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action597<
->(
+fn __action597(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
@@ -36802,30 +35557,16 @@ fn __action597<
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __6.0;
     let __end0 = __6.2;
-    let __temp0 = __action340(
-        __6,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action131(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-        __7,
-        __8,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action598<
->(
+    let __temp0 = __action340(__6);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action131(__0, __1, __2, __3, __4, __5, __temp0, __7, __8)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action598(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
@@ -36834,31 +35575,16 @@ fn __action598<
     __5: (TextSize, ast::Identifier, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __5.2;
     let __end0 = __6.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action131(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-        __6,
-        __7,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action599<
->(
+    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action131(__0, __1, __2, __3, __4, __5, __temp0, __6, __7)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action599(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Expr>, TextSize),
@@ -36868,30 +35594,16 @@ fn __action599<
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, alloc::vec::Vec<ast::MatchCase>, TextSize),
     __8: (TextSize, token::Tok, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action340(
-        __3,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action81(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action600<
->(
+    let __temp0 = __action340(__3);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action81(__0, __1, __2, __temp0, __4, __5, __6, __7, __8)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action600(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Expr>, TextSize),
@@ -36900,461 +35612,363 @@ fn __action600<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::MatchCase>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action81(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action601<
->(
+    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action81(__0, __1, __2, __temp0, __3, __4, __5, __6, __7)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action601(
     __0: (TextSize, TextSize, TextSize),
-    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
-    __2: (TextSize, core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>, TextSize),
+    __1: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
+    __2: (
+        TextSize,
+        core::option::Option<(
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        )>,
+        TextSize,
+    ),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action340(
-        __3,
-    );
+    let __temp0 = __action340(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action266(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __4,
-    )
+    __action266(__0, __1, __2, __temp0, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action602<
->(
+fn __action602(
     __0: (TextSize, TextSize, TextSize),
-    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
-    __2: (TextSize, core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>, TextSize),
+    __1: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
+    __2: (
+        TextSize,
+        core::option::Option<(
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        )>,
+        TextSize,
+    ),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action266(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __3,
-    )
+    __action266(__0, __1, __2, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action603<
->(
+fn __action603(
     __0: (TextSize, TextSize, TextSize),
-    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+    __1: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action340(
-        __3,
-    );
+    let __temp0 = __action340(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action267(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __4,
-    )
+    __action267(__0, __1, __2, __temp0, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action604<
->(
+fn __action604(
     __0: (TextSize, TextSize, TextSize),
-    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+    __1: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action267(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __3,
-    )
+    __action267(__0, __1, __2, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action605<
->(
+fn __action605(
     __0: (TextSize, TextSize, TextSize),
-    __1: (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
+    __1: (
+        TextSize,
+        (
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        ),
+        TextSize,
+    ),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Arguments
-{
+) -> ast::Arguments {
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action340(
-        __2,
-    );
+    let __temp0 = __action340(__2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action268(
-        __0,
-        __1,
-        __temp0,
-        __3,
-    )
+    __action268(__0, __1, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action606<
->(
+fn __action606(
     __0: (TextSize, TextSize, TextSize),
-    __1: (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
+    __1: (
+        TextSize,
+        (
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        ),
+        TextSize,
+    ),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Arguments
-{
+) -> ast::Arguments {
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action268(
-        __0,
-        __1,
-        __temp0,
-        __2,
-    )
+    __action268(__0, __1, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action607<
->(
+fn __action607(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Arguments
-{
+) -> ast::Arguments {
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action340(
-        __2,
-    );
+    let __temp0 = __action340(__2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action269(
-        __0,
-        __1,
-        __temp0,
-        __3,
-    )
+    __action269(__0, __1, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action608<
->(
+fn __action608(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Arguments
-{
+) -> ast::Arguments {
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action269(
-        __0,
-        __1,
-        __temp0,
-        __2,
-    )
+    __action269(__0, __1, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action609<
->(
+fn __action609(
     __0: (TextSize, TextSize, TextSize),
-    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
-    __2: (TextSize, core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>, TextSize),
+    __1: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
+    __2: (
+        TextSize,
+        core::option::Option<(
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        )>,
+        TextSize,
+    ),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action340(
-        __3,
-    );
+    let __temp0 = __action340(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action250(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __4,
-    )
+    __action250(__0, __1, __2, __temp0, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action610<
->(
+fn __action610(
     __0: (TextSize, TextSize, TextSize),
-    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
-    __2: (TextSize, core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>, TextSize),
+    __1: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
+    __2: (
+        TextSize,
+        core::option::Option<(
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        )>,
+        TextSize,
+    ),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action250(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __3,
-    )
+    __action250(__0, __1, __2, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action611<
->(
+fn __action611(
     __0: (TextSize, TextSize, TextSize),
-    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+    __1: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action340(
-        __3,
-    );
+    let __temp0 = __action340(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action251(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __4,
-    )
+    __action251(__0, __1, __2, __temp0, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action612<
->(
+fn __action612(
     __0: (TextSize, TextSize, TextSize),
-    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+    __1: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action251(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __3,
-    )
+    __action251(__0, __1, __2, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action613<
->(
+fn __action613(
     __0: (TextSize, TextSize, TextSize),
-    __1: (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
+    __1: (
+        TextSize,
+        (
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        ),
+        TextSize,
+    ),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Arguments
-{
+) -> ast::Arguments {
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action340(
-        __2,
-    );
+    let __temp0 = __action340(__2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action252(
-        __0,
-        __1,
-        __temp0,
-        __3,
-    )
+    __action252(__0, __1, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action614<
->(
+fn __action614(
     __0: (TextSize, TextSize, TextSize),
-    __1: (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
+    __1: (
+        TextSize,
+        (
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        ),
+        TextSize,
+    ),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Arguments
-{
+) -> ast::Arguments {
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action252(
-        __0,
-        __1,
-        __temp0,
-        __2,
-    )
+    __action252(__0, __1, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action615<
->(
+fn __action615(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Arguments
-{
+) -> ast::Arguments {
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action340(
-        __2,
-    );
+    let __temp0 = __action340(__2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action253(
-        __0,
-        __1,
-        __temp0,
-        __3,
-    )
+    __action253(__0, __1, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action616<
->(
+fn __action616(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Arguments
-{
+) -> ast::Arguments {
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action253(
-        __0,
-        __1,
-        __temp0,
-        __2,
-    )
+    __action253(__0, __1, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action617<
->(
+fn __action617(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Vec<ast::Pattern>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action340(
-        __2,
-    );
+    let __temp0 = __action340(__2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action85(
-        __0,
-        __1,
-        __temp0,
-        __3,
-    )
+    __action85(__0, __1, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action618<
->(
+fn __action618(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Vec<ast::Pattern>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action85(
-        __0,
-        __1,
-        __temp0,
-        __2,
-    )
+    __action85(__0, __1, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action619<
->(
+fn __action619(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
@@ -37362,433 +35976,250 @@ fn __action619<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action340(
-        __4,
-    );
+    let __temp0 = __action340(__4);
     let __temp0 = (__start0, __temp0, __end0);
-    __action102(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __5,
-        __6,
-    )
+    __action102(__0, __1, __2, __3, __temp0, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action620<
->(
+fn __action620(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     __3: (TextSize, ast::Pattern, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action102(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action102(__0, __1, __2, __3, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action621<
->(
+fn __action621(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Expr>
-{
+) -> Vec<ast::Expr> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action340(
-        __1,
-    );
+    let __temp0 = __action340(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action205(
-        __0,
-        __temp0,
-    )
+    __action205(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action622<
->(
-    __0: (TextSize, Vec<ast::Expr>, TextSize),
-) -> Vec<ast::Expr>
-{
+fn __action622(__0: (TextSize, Vec<ast::Expr>, TextSize)) -> Vec<ast::Expr> {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action205(
-        __0,
-        __temp0,
-    )
+    __action205(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action623<
->(
+fn __action623(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action340(
-        __2,
-    );
+    let __temp0 = __action340(__2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action196(
-        __0,
-        __1,
-        __temp0,
-        __3,
-    )
+    __action196(__0, __1, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action624<
->(
+fn __action624(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action196(
-        __0,
-        __1,
-        __temp0,
-        __2,
-    )
+    __action196(__0, __1, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action625<
->(
+fn __action625(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::WithItem>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action340(
-        __2,
-    );
+    let __temp0 = __action340(__2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action152(
-        __0,
-        __1,
-        __temp0,
-        __3,
-    )
+    __action152(__0, __1, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action626<
->(
+fn __action626(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::WithItem>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action152(
-        __0,
-        __1,
-        __temp0,
-        __2,
-    )
+    __action152(__0, __1, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action627<
->(
+fn __action627(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::WithItem>>, TextSize),
     __2: (TextSize, ast::WithItem, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action340(
-        __4,
-    );
+    let __temp0 = __action340(__4);
     let __temp0 = (__start0, __temp0, __end0);
-    __action153(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __5,
-    )
+    __action153(__0, __1, __2, __3, __temp0, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action628<
->(
+fn __action628(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::WithItem>>, TextSize),
     __2: (TextSize, ast::WithItem, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action341(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action341(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action153(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __4,
-    )
+    __action153(__0, __1, __2, __3, __temp0, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action629<
->(
+fn __action629(
     __0: (TextSize, ast::Suite, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __2: (TextSize, ast::Stmt, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> ast::Suite
-{
+) -> ast::Suite {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action364(
-        __3,
-    );
+    let __temp0 = __action364(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action6(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __4,
-    )
+    __action6(__0, __1, __2, __temp0, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action630<
->(
+fn __action630(
     __0: (TextSize, ast::Suite, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __2: (TextSize, ast::Stmt, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Suite
-{
+) -> ast::Suite {
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action365(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action365(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action6(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __3,
-    )
+    __action6(__0, __1, __2, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action631<
->(
+fn __action631(
     __0: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt>
-{
+) -> Vec<ast::Stmt> {
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action364(
-        __2,
-    );
+    let __temp0 = __action364(__2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action10(
-        __0,
-        __1,
-        __temp0,
-        __3,
-    )
+    __action10(__0, __1, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action632<
->(
+fn __action632(
     __0: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt>
-{
+) -> Vec<ast::Stmt> {
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action365(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action365(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action10(
-        __0,
-        __1,
-        __temp0,
-        __2,
-    )
+    __action10(__0, __1, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action633<
->(
+fn __action633(
     __0: (TextSize, Vec<ast::Stmt>, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __2: (TextSize, ast::Stmt, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt>
-{
+) -> Vec<ast::Stmt> {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action364(
-        __3,
-    );
+    let __temp0 = __action364(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action13(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __4,
-    )
+    __action13(__0, __1, __2, __temp0, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action634<
->(
+fn __action634(
     __0: (TextSize, Vec<ast::Stmt>, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __2: (TextSize, ast::Stmt, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt>
-{
+) -> Vec<ast::Stmt> {
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action365(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action365(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action13(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __3,
-    )
+    __action13(__0, __1, __2, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action635<
->(
+fn __action635(
     __0: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Suite
-{
+) -> ast::Suite {
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action364(
-        __2,
-    );
+    let __temp0 = __action364(__2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action8(
-        __0,
-        __1,
-        __temp0,
-        __3,
-    )
+    __action8(__0, __1, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action636<
->(
+fn __action636(
     __0: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Suite
-{
+) -> ast::Suite {
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action365(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action365(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action8(
-        __0,
-        __1,
-        __temp0,
-        __2,
-    )
+    __action8(__0, __1, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action637<
->(
+fn __action637(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -37798,30 +36229,16 @@ fn __action637<
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, ast::Suite, TextSize),
     __8: (TextSize, core::option::Option<ast::Suite>, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action300(
-        __1,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action143(
-        __0,
-        __temp0,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action638<
->(
+    let __temp0 = __action300(__1);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action143(__0, __temp0, __2, __3, __4, __5, __6, __7, __8)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action638(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -37830,31 +36247,16 @@ fn __action638<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
     __7: (TextSize, core::option::Option<ast::Suite>, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action301(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action143(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action639<
->(
+    let __temp0 = __action301(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action143(__0, __temp0, __1, __2, __3, __4, __5, __6, __7)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action639(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, TextSize, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -37864,30 +36266,16 @@ fn __action639<
     __6: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action300(
-        __2,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action157(
-        __0,
-        __1,
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action640<
->(
+    let __temp0 = __action300(__2);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action157(__0, __1, __temp0, __3, __4, __5, __6, __7, __8)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action640(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, TextSize, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -37896,31 +36284,16 @@ fn __action640<
     __5: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action301(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action157(
-        __0,
-        __1,
-        __temp0,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action641<
->(
+    let __temp0 = __action301(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action157(__0, __1, __temp0, __2, __3, __4, __5, __6, __7)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action641(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -37929,29 +36302,16 @@ fn __action641<
     __5: (TextSize, ast::Expr, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> ast::Comprehension
-{
+) -> ast::Comprehension {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action300(
-        __1,
-    );
+    let __temp0 = __action300(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action213(
-        __0,
-        __temp0,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action213(__0, __temp0, __2, __3, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action642<
->(
+fn __action642(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -37959,105 +36319,60 @@ fn __action642<
     __4: (TextSize, ast::Expr, TextSize),
     __5: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Comprehension
-{
+) -> ast::Comprehension {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action301(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action213(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action643<
->(
+    let __temp0 = __action301(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action213(__0, __temp0, __1, __2, __3, __4, __5, __6)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action643(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Vec<ast::WithItem>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action300(
-        __1,
-    );
+    let __temp0 = __action300(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action151(
-        __0,
-        __temp0,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action151(__0, __temp0, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action644<
->(
+fn __action644(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::WithItem>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action301(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action301(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action151(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action151(__0, __temp0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action645<
->(
+fn __action645(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ArgumentList, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> core::option::Option<(token::Tok, ArgumentList, token::Tok)>
-{
+) -> core::option::Option<(token::Tok, ArgumentList, token::Tok)> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action256(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action256(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action254(
-        __temp0,
-    )
+    __action254(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action646<
->(
+fn __action646(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, TextSize, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -38067,1301 +36382,913 @@ fn __action646<
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __4.0;
     let __end0 = __6.2;
-    let __temp0 = __action645(
-        __4,
-        __5,
-        __6,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action164(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __7,
-        __8,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action647<
->(
+    let __temp0 = __action645(__4, __5, __6);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action164(__0, __1, __2, __3, __temp0, __7, __8)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action647(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, TextSize, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Identifier, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action255(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action255(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action164(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action164(__0, __1, __2, __3, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action648<
->(
+fn __action648(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> core::option::Option<Option<Box<ast::Arg>>>
-{
+) -> core::option::Option<Option<Box<ast::Arg>>> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action394(
-        __0,
-        __1,
-    );
+    let __temp0 = __action394(__0, __1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action448(
-        __temp0,
-    )
+    __action448(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action649<
->(
+fn __action649(
     __0: (TextSize, TextSize, TextSize),
-    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+    __1: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.0;
     let __end0 = __3.2;
-    let __temp0 = __action394(
-        __2,
-        __3,
-    );
+    let __temp0 = __action394(__2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action603(
-        __0,
-        __1,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action603(__0, __1, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action650<
->(
+fn __action650(
     __0: (TextSize, TextSize, TextSize),
-    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+    __1: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.0;
     let __end0 = __3.2;
-    let __temp0 = __action394(
-        __2,
-        __3,
-    );
+    let __temp0 = __action394(__2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action604(
-        __0,
-        __1,
-        __temp0,
-        __4,
-    )
+    __action604(__0, __1, __temp0, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action651<
->(
+fn __action651(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __4.0;
     let __end0 = __5.2;
-    let __temp0 = __action648(
-        __4,
-        __5,
-    );
+    let __temp0 = __action648(__4, __5);
     let __temp0 = (__start0, __temp0, __end0);
-    __action399(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action399(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action652<
->(
+fn __action652(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action449(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action449(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action399(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action399(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action653<
->(
+fn __action653(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> core::option::Option<Option<Box<ast::Arg>>>
-{
+) -> core::option::Option<Option<Box<ast::Arg>>> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action402(
-        __0,
-        __1,
-    );
+    let __temp0 = __action402(__0, __1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action437(
-        __temp0,
-    )
+    __action437(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action654<
->(
+fn __action654(
     __0: (TextSize, TextSize, TextSize),
-    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+    __1: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.0;
     let __end0 = __3.2;
-    let __temp0 = __action402(
-        __2,
-        __3,
-    );
+    let __temp0 = __action402(__2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action611(
-        __0,
-        __1,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action611(__0, __1, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action655<
->(
+fn __action655(
     __0: (TextSize, TextSize, TextSize),
-    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+    __1: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.0;
     let __end0 = __3.2;
-    let __temp0 = __action402(
-        __2,
-        __3,
-    );
+    let __temp0 = __action402(__2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action612(
-        __0,
-        __1,
-        __temp0,
-        __4,
-    )
+    __action612(__0, __1, __temp0, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action656<
->(
+fn __action656(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __4.0;
     let __end0 = __5.2;
-    let __temp0 = __action653(
-        __4,
-        __5,
-    );
+    let __temp0 = __action653(__4, __5);
     let __temp0 = (__start0, __temp0, __end0);
-    __action407(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action407(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action657<
->(
+fn __action657(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action438(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action438(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action407(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action407(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action658<
->(
+fn __action658(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::ArgWithDefault, TextSize),
-) -> alloc::vec::Vec<ast::ArgWithDefault>
-{
+) -> alloc::vec::Vec<ast::ArgWithDefault> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action452(
-        __0,
-        __1,
-    );
+    let __temp0 = __action452(__0, __1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action463(
-        __temp0,
-    )
+    __action463(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action659<
->(
+fn __action659(
     __0: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::ArgWithDefault, TextSize),
-) -> alloc::vec::Vec<ast::ArgWithDefault>
-{
+) -> alloc::vec::Vec<ast::ArgWithDefault> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action452(
-        __1,
-        __2,
-    );
+    let __temp0 = __action452(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action464(
-        __0,
-        __temp0,
-    )
+    __action464(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action660<
->(
+fn __action660(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>)
-{
+) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>) {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action450(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action450(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action401(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action401(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action661<
->(
+fn __action661(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>)
-{
+) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>) {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action451(
-        __3,
-    );
+    let __temp0 = __action451(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action401(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action401(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action662<
->(
+fn __action662(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action450(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action450(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action651(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __3,
-        __4,
-    )
+    __action651(__0, __1, __2, __temp0, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action663<
->(
+fn __action663(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action451(
-        __3,
-    );
+    let __temp0 = __action451(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action651(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action651(__0, __1, __2, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action664<
->(
+fn __action664(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action450(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action450(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action652(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action652(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action665<
->(
+fn __action665(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action451(
-        __3,
-    );
+    let __temp0 = __action451(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action652(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action652(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action666<
->(
+fn __action666(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::ArgWithDefault, TextSize),
-) -> alloc::vec::Vec<ast::ArgWithDefault>
-{
+) -> alloc::vec::Vec<ast::ArgWithDefault> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action441(
-        __0,
-        __1,
-    );
+    let __temp0 = __action441(__0, __1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action465(
-        __temp0,
-    )
+    __action465(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action667<
->(
+fn __action667(
     __0: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::ArgWithDefault, TextSize),
-) -> alloc::vec::Vec<ast::ArgWithDefault>
-{
+) -> alloc::vec::Vec<ast::ArgWithDefault> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action441(
-        __1,
-        __2,
-    );
+    let __temp0 = __action441(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action466(
-        __0,
-        __temp0,
-    )
+    __action466(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action668<
->(
+fn __action668(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>)
-{
+) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>) {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action439(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action439(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action409(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action409(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action669<
->(
+fn __action669(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>)
-{
+) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>) {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action440(
-        __3,
-    );
+    let __temp0 = __action440(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action409(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action409(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action670<
->(
+fn __action670(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action439(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action439(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action656(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __3,
-        __4,
-    )
+    __action656(__0, __1, __2, __temp0, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action671<
->(
+fn __action671(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action440(
-        __3,
-    );
+    let __temp0 = __action440(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action656(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action656(__0, __1, __2, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action672<
->(
+fn __action672(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action439(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action439(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action657(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action657(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action673<
->(
+fn __action673(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action440(
-        __3,
-    );
+    let __temp0 = __action440(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action657(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action657(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action674<
->(
+fn __action674(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action455(
-        __2,
-    );
+    let __temp0 = __action455(__2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action662(
-        __0,
-        __1,
-        __temp0,
-        __3,
-        __4,
-    )
+    __action662(__0, __1, __temp0, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action675<
->(
+fn __action675(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action456(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action456(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action662(
-        __0,
-        __1,
-        __temp0,
-        __2,
-        __3,
-    )
+    __action662(__0, __1, __temp0, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action676<
->(
+fn __action676(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action455(
-        __2,
-    );
+    let __temp0 = __action455(__2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action663(
-        __0,
-        __1,
-        __temp0,
-        __3,
-        __4,
-        __5,
-    )
+    __action663(__0, __1, __temp0, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action677<
->(
+fn __action677(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action456(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action456(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action663(
-        __0,
-        __1,
-        __temp0,
-        __2,
-        __3,
-        __4,
-    )
+    __action663(__0, __1, __temp0, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action678<
->(
+fn __action678(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action455(
-        __2,
-    );
+    let __temp0 = __action455(__2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action664(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action664(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action679<
->(
+fn __action679(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action456(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action456(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action664(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action664(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action680<
->(
+fn __action680(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action455(
-        __2,
-    );
+    let __temp0 = __action455(__2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action665(
-        __0,
-        __1,
-        __temp0,
-        __3,
-    )
+    __action665(__0, __1, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action681<
->(
+fn __action681(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action456(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action456(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action665(
-        __0,
-        __1,
-        __temp0,
-        __2,
-    )
+    __action665(__0, __1, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action682<
->(
+fn __action682(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-) -> (TextSize, ast::Expr, ast::Suite)
-{
+) -> (TextSize, ast::Expr, ast::Suite) {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action307(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action307(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action683<
->(
+fn __action683(
     __0: (TextSize, (String, StringKind, bool), TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> (TextSize, (String, StringKind, bool), TextSize)
-{
+) -> (TextSize, (String, StringKind, bool), TextSize) {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action316(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action316(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action684<
->(
+fn __action684(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action108(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action108(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action685<
->(
+fn __action685(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action433(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action433(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action686<
->(
+fn __action686(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action492(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action492(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action687<
->(
+fn __action687(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action417(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action417(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action688<
->(
+fn __action688(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action461(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action461(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action689<
->(
+fn __action689(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action474(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action474(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action690<
->(
+fn __action690(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action519(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action519(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action691<
->(
+fn __action691(
     __0: (TextSize, ast::Pattern, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Pattern,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Pattern, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action89(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action89(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action692<
->(
+fn __action692(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action70(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action70(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action693<
->(
-    __0: (TextSize, alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+fn __action693(
+    __0: (
+        TextSize,
+        alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>,
+        TextSize,
+    ),
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action500(
-        __temp0,
-        __0,
-    )
+    __action500(__temp0, __0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action694<
->(
+fn __action694(
     __0: (TextSize, ast::Constant, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action501(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action501(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action695<
->(
+fn __action695(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action502(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action502(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action696<
->(
+fn __action696(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action503(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action503(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action697<
->(
+fn __action697(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action504(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action504(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action698<
->(
+fn __action698(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action563(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action563(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action699<
->(
+fn __action699(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action564(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action564(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action700<
->(
+fn __action700(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -39369,437 +37296,253 @@ fn __action700<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action565(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action565(__temp0, __0, __1, __2, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action701<
->(
+fn __action701(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action566(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action566(__temp0, __0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action702<
->(
+fn __action702(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action507(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action507(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action703<
->(
+fn __action703(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action509(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action509(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action704<
->(
+fn __action704(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action510(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action510(__0, __temp0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action705<
->(
+fn __action705(
     __0: (TextSize, token::Tok, TextSize),
-    __1: (TextSize, core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>, TextSize),
+    __1: (
+        TextSize,
+        core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>,
+        TextSize,
+    ),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action511(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action511(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action706<
->(
+fn __action706(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, (ast::Expr, ast::Expr), TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action512(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action512(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action707<
->(
+fn __action707(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action513(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action513(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action708<
->(
+fn __action708(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action514(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action514(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action709<
->(
+fn __action709(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action515(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action515(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action710<
->(
+fn __action710(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action516(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action516(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action711<
->(
+fn __action711(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action517(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action517(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action712<
->(
+fn __action712(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action518(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action518(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action713<
->(
-    __0: (TextSize, alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+fn __action713(
+    __0: (
+        TextSize,
+        alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>,
+        TextSize,
+    ),
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action545(
-        __temp0,
-        __0,
-    )
+    __action545(__temp0, __0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action714<
->(
+fn __action714(
     __0: (TextSize, ast::Constant, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action546(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action546(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action715<
->(
+fn __action715(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action547(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action547(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action716<
->(
+fn __action716(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action548(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action548(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action717<
->(
+fn __action717(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action549(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action549(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action718<
->(
+fn __action718(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -39807,549 +37550,311 @@ fn __action718<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action567(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action567(__temp0, __0, __1, __2, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action719<
->(
+fn __action719(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action568(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action568(__temp0, __0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action720<
->(
+fn __action720(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action551(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action551(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action721<
->(
+fn __action721(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action553(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action553(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action722<
->(
+fn __action722(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action554(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action554(__0, __temp0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action723<
->(
+fn __action723(
     __0: (TextSize, token::Tok, TextSize),
-    __1: (TextSize, core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>, TextSize),
+    __1: (
+        TextSize,
+        core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>,
+        TextSize,
+    ),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action555(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action555(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action724<
->(
+fn __action724(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, (ast::Expr, ast::Expr), TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action556(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action556(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action725<
->(
+fn __action725(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action557(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action557(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action726<
->(
+fn __action726(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action558(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action558(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action727<
->(
+fn __action727(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action559(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action559(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action728<
->(
+fn __action728(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action560(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action560(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action729<
->(
+fn __action729(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action561(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action561(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action730<
->(
+fn __action730(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action562(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action562(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action731<
->(
+fn __action731(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ArgumentList, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action497(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action497(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action732<
->(
+fn __action732(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action498(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action498(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action733<
->(
+fn __action733(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action499(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action499(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action734<
->(
+fn __action734(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ArgumentList, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action542(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action542(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action735<
->(
+fn __action735(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action543(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action543(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action736<
->(
+fn __action736(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action544(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action544(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action737<
->(
+fn __action737(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action490(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action490(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action738<
->(
+fn __action738(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action539(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action539(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action739<
->(
+fn __action739(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action115(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action115(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action740<
->(
+fn __action740(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
@@ -40358,58 +37863,31 @@ fn __action740<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action646(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action741<
->(
+    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action646(__0, __temp0, __1, __2, __3, __4, __5, __6, __7)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action741(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action647(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action647(__0, __temp0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action742<
->(
+fn __action742(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
@@ -40418,31 +37896,16 @@ fn __action742<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action569(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action743<
->(
+    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action569(__temp0, __0, __1, __2, __3, __4, __5, __6, __7)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action743(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
@@ -40450,167 +37913,92 @@ fn __action743<
     __4: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action570(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action744<
->(
+    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action570(__temp0, __0, __1, __2, __3, __4, __5, __6)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action744(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action571(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action571(__temp0, __0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action745<
->(
+fn __action745(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action572(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action572(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action746<
->(
+fn __action746(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action573(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action573(__temp0, __0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action747<
->(
+fn __action747(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action574(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action574(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action748<
->(
+fn __action748(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action136(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action136(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action749<
->(
+fn __action749(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
@@ -40619,31 +38007,16 @@ fn __action749<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action575(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action750<
->(
+    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action575(__temp0, __0, __1, __2, __3, __4, __5, __6, __7)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action750(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
@@ -40651,687 +38024,385 @@ fn __action750<
     __4: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action576(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action751<
->(
+    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action576(__temp0, __0, __1, __2, __3, __4, __5, __6)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action751(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action577(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action577(__temp0, __0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action752<
->(
+fn __action752(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action578(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action578(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action753<
->(
+fn __action753(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action579(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action579(__temp0, __0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action754<
->(
+fn __action754(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action580(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action580(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action755<
->(
+fn __action755(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action140(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action140(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action756<
->(
+fn __action756(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, alloc::vec::Vec<(ast::CmpOp, ast::Expr)>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action469(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action469(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action757<
->(
+fn __action757(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, alloc::vec::Vec<(ast::CmpOp, ast::Expr)>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action478(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action478(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action758<
->(
+fn __action758(
     __0: (TextSize, ast::Constant, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action105(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action105(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action759<
->(
+fn __action759(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action107(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action107(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action760<
->(
+fn __action760(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action165(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action165(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action761<
->(
+fn __action761(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action23(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action23(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action762<
->(
+fn __action762(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Arg
-{
+) -> ast::Arg {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action163(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action163(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action763<
->(
+fn __action763(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler
-{
+) -> ast::ExceptHandler {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action149(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action149(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action764<
->(
+fn __action764(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, (ast::Expr, ast::Identifier), TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler
-{
+) -> ast::ExceptHandler {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action150(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action150(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action765<
->(
+fn __action765(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler
-{
+) -> ast::ExceptHandler {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action147(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action147(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action766<
->(
+fn __action766(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, (ast::Expr, ast::Identifier), TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler
-{
+) -> ast::ExceptHandler {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action148(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action148(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action767<
->(
+fn __action767(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action238(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action238(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action768<
->(
+fn __action768(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action484(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action484(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action769<
->(
+fn __action769(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action24(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action24(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action770<
->(
+fn __action770(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action25(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action25(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action771<
->(
+fn __action771(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action26(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action26(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action772<
->(
+fn __action772(
     __0: (TextSize, ast::UnaryOp, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action482(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action482(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action773<
->(
+fn __action773(
     __0: (TextSize, ast::UnaryOp, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action535(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action535(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action774<
->(
+fn __action774(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action50(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action50(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action775<
->(
+fn __action775(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action51(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action51(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action776<
->(
+fn __action776(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action52(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action52(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action777<
->(
+fn __action777(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action53(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action53(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action778<
->(
+fn __action778(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -41340,31 +38411,16 @@ fn __action778<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
     __7: (TextSize, core::option::Option<ast::Suite>, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action637(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action637(__temp0, __0, __1, __2, __3, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action779<
->(
+fn __action779(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -41372,30 +38428,16 @@ fn __action779<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Suite, TextSize),
     __6: (TextSize, core::option::Option<ast::Suite>, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action638(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action780<
->(
+    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action638(__temp0, __0, __1, __2, __3, __4, __5, __6)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action780(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -41404,31 +38446,16 @@ fn __action780<
     __5: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action639(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action781<
->(
+    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action639(__0, __temp0, __1, __2, __3, __4, __5, __6, __7)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action781(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
@@ -41436,820 +38463,494 @@ fn __action781<
     __4: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action640(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action782<
->(
+    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action640(__0, __temp0, __1, __2, __3, __4, __5, __6)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action782(
     __0: (TextSize, ast::Expr, TextSize),
-    __1: (TextSize, core::option::Option<Vec<ast::Comprehension>>, TextSize),
+    __1: (
+        TextSize,
+        core::option::Option<Vec<ast::Comprehension>>,
+        TextSize,
+    ),
     __2: (TextSize, TextSize, TextSize),
-) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
-{
+) -> (
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+) {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action217(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action217(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action783<
->(
+fn __action783(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
-{
+) -> (
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+) {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action218(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action218(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action784<
->(
+fn __action784(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
-{
+) -> (
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+) {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action219(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action219(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action785<
->(
+fn __action785(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
-{
+) -> (
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+) {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action220(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action220(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action786<
->(
+fn __action786(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action585(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action585(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action787<
->(
+fn __action787(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action586(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action586(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action788<
->(
+fn __action788(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action587(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action587(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action789<
->(
+fn __action789(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action588(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action588(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action790<
->(
+fn __action790(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Identifier>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action68(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action68(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action791<
->(
+fn __action791(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-    __4: (TextSize, alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>, TextSize),
+    __4: (
+        TextSize,
+        alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>,
+        TextSize,
+    ),
     __5: (TextSize, core::option::Option<ast::Suite>, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action141(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action141(__temp0, __0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action792<
->(
+fn __action792(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, core::option::Option<ast::Identifier>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Alias
-{
+) -> ast::Alias {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action351(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action351(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action793<
->(
+fn __action793(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, core::option::Option<ast::Identifier>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Alias
-{
+) -> ast::Alias {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action344(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action344(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action794<
->(
+fn __action794(
     __0: (TextSize, Vec<ast::Alias>, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> Vec<ast::Alias>
-{
+) -> Vec<ast::Alias> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action63(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action63(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action795<
->(
+fn __action795(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Alias>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Vec<ast::Alias>
-{
+) -> Vec<ast::Alias> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action589(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action589(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action796<
->(
+fn __action796(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Alias>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Vec<ast::Alias>
-{
+) -> Vec<ast::Alias> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action590(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action590(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action797<
->(
+fn __action797(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> Vec<ast::Alias>
-{
+) -> Vec<ast::Alias> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action65(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action65(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action798<
->(
+fn __action798(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Alias>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action57(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action57(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action799<
->(
+fn __action799(
     __0: (TextSize, token::Tok, TextSize),
-    __1: (TextSize, (Option<ast::Int>, Option<ast::Identifier>), TextSize),
+    __1: (
+        TextSize,
+        (Option<ast::Int>, Option<ast::Identifier>),
+        TextSize,
+    ),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Vec<ast::Alias>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action58(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action58(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action800<
->(
+fn __action800(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Arguments>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action171(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action171(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action801<
->(
+fn __action801(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action109(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action109(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action802<
->(
+fn __action802(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action110(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action110(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action803<
->(
+fn __action803(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action111(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action111(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action804<
->(
+fn __action804(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action112(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action112(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action805<
->(
+fn __action805(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action113(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action113(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action806<
->(
-    __0: (TextSize, alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>, TextSize),
+fn __action806(
+    __0: (
+        TextSize,
+        alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>,
+        TextSize,
+    ),
     __1: (TextSize, TextSize, TextSize),
-) -> Result<ast::Pattern,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Pattern, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action114(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action114(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action807<
->(
+fn __action807(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action123(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action123(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action808<
->(
+fn __action808(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action124(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action124(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action809<
->(
+fn __action809(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action125(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action125(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action810<
->(
-    __0: (TextSize, alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+fn __action810(
+    __0: (
+        TextSize,
+        alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>,
+        TextSize,
+    ),
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action126(
-        __temp0,
-        __0,
-    )
+    __action126(__temp0, __0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action811<
->(
+fn __action811(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action128(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action128(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action812<
->(
+fn __action812(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action593(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action593(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action813<
->(
+fn __action813(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action594(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action594(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action814<
->(
+fn __action814(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action595(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action595(__temp0, __0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action815<
->(
+fn __action815(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action596(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action596(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action816<
->(
+fn __action816(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -42258,31 +38959,16 @@ fn __action816<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action597(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action597(__temp0, __0, __1, __2, __3, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action817<
->(
+fn __action817(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -42290,128 +38976,71 @@ fn __action817<
     __4: (TextSize, ast::Identifier, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action598(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action598(__temp0, __0, __1, __2, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action818<
->(
+fn __action818(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Pattern, TextSize),
     __2: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Suite, TextSize),
-) -> ast::MatchCase
-{
+) -> ast::MatchCase {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action82(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action82(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action819<
->(
+fn __action819(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action116(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action116(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action820<
->(
+fn __action820(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action117(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action117(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action821<
->(
+fn __action821(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action118(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action118(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action822<
->(
+fn __action822(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -42419,30 +39048,16 @@ fn __action822<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, alloc::vec::Vec<ast::MatchCase>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action79(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action79(__temp0, __0, __1, __2, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action823<
->(
+fn __action823(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -42451,31 +39066,16 @@ fn __action823<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::MatchCase>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action80(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action80(__temp0, __0, __1, __2, __3, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action824<
->(
+fn __action824(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -42484,31 +39084,16 @@ fn __action824<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::MatchCase>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action599(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action599(__temp0, __0, __1, __2, __3, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action825<
->(
+fn __action825(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -42516,1262 +39101,890 @@ fn __action825<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, alloc::vec::Vec<ast::MatchCase>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action600(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action826<
->(
+    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action600(__temp0, __0, __1, __2, __3, __4, __5, __6)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action826(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action170(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action170(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action827<
->(
+fn __action827(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Identifier>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action69(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action69(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action828<
->(
+fn __action828(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action431(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action431(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action829<
->(
+fn __action829(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action476(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action476(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action830<
->(
+fn __action830(
     __0: (TextSize, Vec<ast::Pattern>, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action91(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action91(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action831<
->(
+fn __action831(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action230(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action230(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action832<
->(
+fn __action832(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action459(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action459(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action833<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
-    __1: (TextSize, core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>, TextSize),
+fn __action833(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
+    __1: (
+        TextSize,
+        core::option::Option<(
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        )>,
+        TextSize,
+    ),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action601(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action834<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
-    __1: (TextSize, core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>, TextSize),
+    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action601(__temp0, __0, __1, __2, __3)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action834(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
+    __1: (
+        TextSize,
+        core::option::Option<(
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        )>,
+        TextSize,
+    ),
     __2: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action602(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action602(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action835<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action835(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action649(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action649(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action836<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action836(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action650(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action650(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action837<
->(
-    __0: (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
+fn __action837(
+    __0: (
+        TextSize,
+        (
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        ),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Arguments
-{
+) -> ast::Arguments {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action605(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action605(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action838<
->(
-    __0: (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
+fn __action838(
+    __0: (
+        TextSize,
+        (
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        ),
+        TextSize,
+    ),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Arguments
-{
+) -> ast::Arguments {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action606(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action606(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action839<
->(
+fn __action839(
     __0: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Arguments
-{
+) -> ast::Arguments {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action607(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action607(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action840<
->(
+fn __action840(
     __0: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Arguments
-{
+) -> ast::Arguments {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action608(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action608(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action841<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
-    __1: (TextSize, core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>, TextSize),
+fn __action841(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
+    __1: (
+        TextSize,
+        core::option::Option<(
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        )>,
+        TextSize,
+    ),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action609(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action842<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
-    __1: (TextSize, core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>, TextSize),
+    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action609(__temp0, __0, __1, __2, __3)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action842(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
+    __1: (
+        TextSize,
+        core::option::Option<(
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        )>,
+        TextSize,
+    ),
     __2: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action610(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action610(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action843<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action843(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action654(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action654(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action844<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action844(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action655(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action655(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action845<
->(
-    __0: (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
+fn __action845(
+    __0: (
+        TextSize,
+        (
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        ),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Arguments
-{
+) -> ast::Arguments {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action613(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action613(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action846<
->(
-    __0: (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
+fn __action846(
+    __0: (
+        TextSize,
+        (
+            Option<Box<ast::Arg>>,
+            Vec<ast::ArgWithDefault>,
+            Option<Box<ast::Arg>>,
+        ),
+        TextSize,
+    ),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Arguments
-{
+) -> ast::Arguments {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action614(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action614(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action847<
->(
+fn __action847(
     __0: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Arguments
-{
+) -> ast::Arguments {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action615(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action615(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action848<
->(
+fn __action848(
     __0: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Arguments
-{
+) -> ast::Arguments {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action616(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action616(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action849<
->(
+fn __action849(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action674(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action674(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action850<
->(
+fn __action850(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action675(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action675(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action851<
->(
+fn __action851(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action676(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action676(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action852<
->(
+fn __action852(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action677(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action677(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action853<
->(
+fn __action853(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action678(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action678(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action854<
->(
+fn __action854(
     __0: (TextSize, token::Tok, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action679(
-        __temp0,
-        __0,
-    )
+    __action679(__temp0, __0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action855<
->(
+fn __action855(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action680(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action680(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action856<
->(
+fn __action856(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action681(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action681(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action857<
->(
+fn __action857(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action670(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action670(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action858<
->(
+fn __action858(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action671(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action671(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action859<
->(
+fn __action859(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Arg>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action672(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action672(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action860<
->(
+fn __action860(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action673(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action673(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action861<
->(
+fn __action861(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Arguments>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action158(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action158(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action862<
->(
+fn __action862(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action22(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action22(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action863<
->(
+fn __action863(
     __0: (TextSize, ast::Pattern, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action84(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action84(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action864<
->(
+fn __action864(
     __0: (TextSize, Vec<ast::Pattern>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action617(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action617(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action865<
->(
+fn __action865(
     __0: (TextSize, Vec<ast::Pattern>, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action618(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action618(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action866<
->(
+fn __action866(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action488(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action488(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action867<
->(
+fn __action867(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action537(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action537(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action868<
->(
+fn __action868(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action55(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action55(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action869<
->(
+fn __action869(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action56(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action56(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action870<
->(
+fn __action870(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Pattern, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action99(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action99(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action871<
->(
+fn __action871(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action100(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action100(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action872<
->(
+fn __action872(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Pattern, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action101(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action101(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action873<
->(
+fn __action873(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     __2: (TextSize, ast::Pattern, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action619(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action619(__temp0, __0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action874<
->(
+fn __action874(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     __2: (TextSize, ast::Pattern, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action620(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action620(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action875<
->(
+fn __action875(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Pattern>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action103(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action103(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action876<
->(
+fn __action876(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action467(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action467(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action877<
->(
+fn __action877(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action494(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action494(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action878<
->(
+fn __action878(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -43779,464 +39992,260 @@ fn __action878<
     __4: (TextSize, ast::Expr, TextSize),
     __5: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Comprehension
-{
+) -> ast::Comprehension {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action641(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action641(__temp0, __0, __1, __2, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action879<
->(
+fn __action879(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Comprehension
-{
+) -> ast::Comprehension {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action642(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action642(__temp0, __0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action880<
->(
+fn __action880(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Expr>, TextSize),
-) -> Option<ast::Expr>
-{
+) -> Option<ast::Expr> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action199(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action199(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action881<
->(
+fn __action881(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action211(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action211(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action882<
->(
+fn __action882(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Identifier, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action104(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action104(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action883<
->(
+fn __action883(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Arg
-{
+) -> ast::Arg {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action162(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action162(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action884<
->(
+fn __action884(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Arg
-{
+) -> ast::Arg {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action160(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action160(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action885<
->(
+fn __action885(
     __0: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __3: (TextSize, core::option::Option<Option<ast::Expr>>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action198(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action198(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action886<
->(
+fn __action886(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action194(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action194(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action887<
->(
+fn __action887(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action195(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action195(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action888<
->(
+fn __action888(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action623(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action623(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action889<
->(
+fn __action889(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action624(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action624(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action890<
->(
+fn __action890(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action480(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action480(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action891<
->(
+fn __action891(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action521(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action521(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action892<
->(
+fn __action892(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Expr, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action359(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action359(__temp0, __0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action893<
->(
+fn __action893(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Expr, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action389(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action389(__temp0, __0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action894<
->(
+fn __action894(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Suite, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Mod
-{
+) -> ast::Mod {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action1(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action895<
->(
+fn __action895(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Suite, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Mod
-{
+) -> ast::Mod {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action2(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action2(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action896<
->(
+fn __action896(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<token::Tok>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Mod
-{
+) -> ast::Mod {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action3(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action3(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action897<
->(
+fn __action897(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -44244,30 +40253,16 @@ fn __action897<
     __4: (TextSize, core::option::Option<ast::Suite>, TextSize),
     __5: (TextSize, core::option::Option<ast::Suite>, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action144(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action144(__temp0, __0, __1, __2, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action898<
->(
+fn __action898(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -44275,671 +40270,443 @@ fn __action898<
     __4: (TextSize, core::option::Option<ast::Suite>, TextSize),
     __5: (TextSize, core::option::Option<ast::Suite>, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action145(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action145(__temp0, __0, __1, __2, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action899<
->(
+fn __action899(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action146(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action146(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action900<
->(
+fn __action900(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::ArgWithDefault
-{
+) -> ast::ArgWithDefault {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action161(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action161(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action901<
->(
+fn __action901(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::ArgWithDefault
-{
+) -> ast::ArgWithDefault {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action159(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action159(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action902<
->(
+fn __action902(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action119(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action119(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action903<
->(
+fn __action903(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
     __4: (TextSize, core::option::Option<ast::Suite>, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action142(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action142(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action904<
->(
+fn __action904(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::WithItem
-{
+) -> ast::WithItem {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action284(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action284(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action905<
->(
+fn __action905(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::WithItem
-{
+) -> ast::WithItem {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action285(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action285(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action906<
->(
+fn __action906(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::WithItem
-{
+) -> ast::WithItem {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action286(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action286(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action907<
->(
+fn __action907(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::WithItem
-{
+) -> ast::WithItem {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action279(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action279(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action908<
->(
+fn __action908(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::WithItem
-{
+) -> ast::WithItem {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action280(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action280(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action909<
->(
+fn __action909(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action156(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action156(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action910<
->(
+fn __action910(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::WithItem>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action643(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action643(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action911<
->(
+fn __action911(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::WithItem>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action644(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action644(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action912<
->(
+fn __action912(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action410(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action410(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action913<
->(
+fn __action913(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action486(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action486(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action914<
->(
+fn __action914(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action166(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action166(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action915<
->(
+fn __action915(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action373(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action167(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action167(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action916<
->(
+fn __action916(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action849(
-        __1,
-        __2,
-        __3,
-        __4,
-    )?;
+    let __temp0 = __action849(__1, __2, __3, __4)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action398(
-        __0,
-        __temp0,
-    ))
+    Ok(__action398(__0, __temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action917<
->(
+fn __action917(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action850(
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action850(__1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action398(
-        __0,
-        __temp0,
-    ))
+    Ok(__action398(__0, __temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action918<
->(
+fn __action918(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.0;
     let __end0 = __5.2;
-    let __temp0 = __action851(
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )?;
+    let __temp0 = __action851(__1, __2, __3, __4, __5)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action398(
-        __0,
-        __temp0,
-    ))
+    Ok(__action398(__0, __temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action919<
->(
+fn __action919(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action852(
-        __1,
-        __2,
-        __3,
-        __4,
-    )?;
+    let __temp0 = __action852(__1, __2, __3, __4)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action398(
-        __0,
-        __temp0,
-    ))
+    Ok(__action398(__0, __temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action920<
->(
+fn __action920(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action853(
-        __1,
-        __2,
-    )?;
+    let __temp0 = __action853(__1, __2)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action398(
-        __0,
-        __temp0,
-    ))
+    Ok(__action398(__0, __temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action921<
->(
+fn __action921(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action854(
-        __1,
-    )?;
+    let __temp0 = __action854(__1)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action398(
-        __0,
-        __temp0,
-    ))
+    Ok(__action398(__0, __temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action922<
->(
+fn __action922(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action855(
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action855(__1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action398(
-        __0,
-        __temp0,
-    ))
+    Ok(__action398(__0, __temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action923<
->(
+fn __action923(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action856(
-        __1,
-        __2,
-    )?;
+    let __temp0 = __action856(__1, __2)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action398(
-        __0,
-        __temp0,
-    ))
+    Ok(__action398(__0, __temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action924<
->(
+fn __action924(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action849(
-        __0,
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action849(__0, __1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action837(
-        __temp0,
-        __4,
-        __5,
-    ))
+    Ok(__action837(__temp0, __4, __5))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action925<
->(
+fn __action925(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action850(
-        __0,
-        __1,
-        __2,
-    )?;
+    let __temp0 = __action850(__0, __1, __2)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action837(
-        __temp0,
-        __3,
-        __4,
-    ))
+    Ok(__action837(__temp0, __3, __4))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action926<
->(
+fn __action926(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
@@ -44947,516 +40714,373 @@ fn __action926<
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __4.2;
-    let __temp0 = __action851(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )?;
+    let __temp0 = __action851(__0, __1, __2, __3, __4)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action837(
-        __temp0,
-        __5,
-        __6,
-    ))
+    Ok(__action837(__temp0, __5, __6))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action927<
->(
+fn __action927(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action852(
-        __0,
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action852(__0, __1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action837(
-        __temp0,
-        __4,
-        __5,
-    ))
+    Ok(__action837(__temp0, __4, __5))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action928<
->(
+fn __action928(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action853(
-        __0,
-        __1,
-    )?;
+    let __temp0 = __action853(__0, __1)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action837(
-        __temp0,
-        __2,
-        __3,
-    ))
+    Ok(__action837(__temp0, __2, __3))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action929<
->(
+fn __action929(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action854(
-        __0,
-    )?;
+    let __temp0 = __action854(__0)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action837(
-        __temp0,
-        __1,
-        __2,
-    ))
+    Ok(__action837(__temp0, __1, __2))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action930<
->(
+fn __action930(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action855(
-        __0,
-        __1,
-        __2,
-    )?;
+    let __temp0 = __action855(__0, __1, __2)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action837(
-        __temp0,
-        __3,
-        __4,
-    ))
+    Ok(__action837(__temp0, __3, __4))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action931<
->(
+fn __action931(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action856(
-        __0,
-        __1,
-    )?;
+    let __temp0 = __action856(__0, __1)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action837(
-        __temp0,
-        __2,
-        __3,
-    ))
+    Ok(__action837(__temp0, __2, __3))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action932<
->(
+fn __action932(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action849(
-        __0,
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action849(__0, __1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action838(
-        __temp0,
-        __4,
-    ))
+    Ok(__action838(__temp0, __4))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action933<
->(
+fn __action933(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action850(
-        __0,
-        __1,
-        __2,
-    )?;
+    let __temp0 = __action850(__0, __1, __2)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action838(
-        __temp0,
-        __3,
-    ))
+    Ok(__action838(__temp0, __3))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action934<
->(
+fn __action934(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __4.2;
-    let __temp0 = __action851(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )?;
+    let __temp0 = __action851(__0, __1, __2, __3, __4)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action838(
-        __temp0,
-        __5,
-    ))
+    Ok(__action838(__temp0, __5))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action935<
->(
+fn __action935(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action852(
-        __0,
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action852(__0, __1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action838(
-        __temp0,
-        __4,
-    ))
+    Ok(__action838(__temp0, __4))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action936<
->(
+fn __action936(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action853(
-        __0,
-        __1,
-    )?;
+    let __temp0 = __action853(__0, __1)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action838(
-        __temp0,
-        __2,
-    ))
+    Ok(__action838(__temp0, __2))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action937<
->(
+fn __action937(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action854(
-        __0,
-    )?;
+    let __temp0 = __action854(__0)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action838(
-        __temp0,
-        __1,
-    ))
+    Ok(__action838(__temp0, __1))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action938<
->(
+fn __action938(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action855(
-        __0,
-        __1,
-        __2,
-    )?;
+    let __temp0 = __action855(__0, __1, __2)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action838(
-        __temp0,
-        __3,
-    ))
+    Ok(__action838(__temp0, __3))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action939<
->(
+fn __action939(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action856(
-        __0,
-        __1,
-    )?;
+    let __temp0 = __action856(__0, __1)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action838(
-        __temp0,
-        __2,
-    ))
+    Ok(__action838(__temp0, __2))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action940<
->(
+fn __action940(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    core::option::Option<(
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    )>,
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __4.2;
-    let __temp0 = __action916(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )?;
+    let __temp0 = __action916(__0, __1, __2, __3, __4)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action396(
-        __temp0,
-    ))
+    Ok(__action396(__temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action941<
->(
+fn __action941(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    core::option::Option<(
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    )>,
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action917(
-        __0,
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action917(__0, __1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action396(
-        __temp0,
-    ))
+    Ok(__action396(__temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action942<
->(
+fn __action942(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    core::option::Option<(
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    )>,
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __5.2;
-    let __temp0 = __action918(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )?;
+    let __temp0 = __action918(__0, __1, __2, __3, __4, __5)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action396(
-        __temp0,
-    ))
+    Ok(__action396(__temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action943<
->(
+fn __action943(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    core::option::Option<(
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    )>,
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __4.2;
-    let __temp0 = __action919(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )?;
+    let __temp0 = __action919(__0, __1, __2, __3, __4)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action396(
-        __temp0,
-    ))
+    Ok(__action396(__temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action944<
->(
+fn __action944(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
-) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    core::option::Option<(
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    )>,
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action920(
-        __0,
-        __1,
-        __2,
-    )?;
+    let __temp0 = __action920(__0, __1, __2)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action396(
-        __temp0,
-    ))
+    Ok(__action396(__temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action945<
->(
+fn __action945(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    core::option::Option<(
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    )>,
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action921(
-        __0,
-        __1,
-    )?;
+    let __temp0 = __action921(__0, __1)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action396(
-        __temp0,
-    ))
+    Ok(__action396(__temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action946<
->(
+fn __action946(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    core::option::Option<(
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    )>,
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action922(
-        __0,
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action922(__0, __1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action396(
-        __temp0,
-    ))
+    Ok(__action396(__temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action947<
->(
+fn __action947(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    core::option::Option<(
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    )>,
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action923(
-        __0,
-        __1,
-        __2,
-    )?;
+    let __temp0 = __action923(__0, __1, __2)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action396(
-        __temp0,
-    ))
+    Ok(__action396(__temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action948<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action948(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
@@ -45464,59 +41088,42 @@ fn __action948<
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __5.2;
-    let __temp0 = __action940(
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )?;
+    let __temp0 = __action940(__1, __2, __3, __4, __5)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action833(
-        __0,
-        __temp0,
-        __6,
-        __7,
-    )
+    __action833(__0, __temp0, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action949<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action949(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action941(
-        __1,
-        __2,
-        __3,
-        __4,
-    )?;
+    let __temp0 = __action941(__1, __2, __3, __4)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action833(
-        __0,
-        __temp0,
-        __5,
-        __6,
-    )
+    __action833(__0, __temp0, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action950<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action950(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
@@ -45525,31 +41132,21 @@ fn __action950<
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __6.2;
-    let __temp0 = __action942(
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )?;
+    let __temp0 = __action942(__1, __2, __3, __4, __5, __6)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action833(
-        __0,
-        __temp0,
-        __7,
-        __8,
-    )
+    __action833(__0, __temp0, __7, __8)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action951<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action951(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
@@ -45557,217 +41154,159 @@ fn __action951<
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __5.2;
-    let __temp0 = __action943(
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )?;
+    let __temp0 = __action943(__1, __2, __3, __4, __5)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action833(
-        __0,
-        __temp0,
-        __6,
-        __7,
-    )
+    __action833(__0, __temp0, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action952<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action952(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action944(
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action944(__1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action833(
-        __0,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action833(__0, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action953<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action953(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action945(
-        __1,
-        __2,
-    )?;
+    let __temp0 = __action945(__1, __2)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action833(
-        __0,
-        __temp0,
-        __3,
-        __4,
-    )
+    __action833(__0, __temp0, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action954<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action954(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action946(
-        __1,
-        __2,
-        __3,
-        __4,
-    )?;
+    let __temp0 = __action946(__1, __2, __3, __4)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action833(
-        __0,
-        __temp0,
-        __5,
-        __6,
-    )
+    __action833(__0, __temp0, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action955<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action955(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action947(
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action947(__1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action833(
-        __0,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action833(__0, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action956<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action956(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action397(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action397(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action833(
-        __0,
-        __temp0,
-        __1,
-        __2,
-    )
+    __action833(__0, __temp0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action957<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action957(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __5.2;
-    let __temp0 = __action940(
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )?;
+    let __temp0 = __action940(__1, __2, __3, __4, __5)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action834(
-        __0,
-        __temp0,
-        __6,
-    )
+    __action834(__0, __temp0, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action958<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action958(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action941(
-        __1,
-        __2,
-        __3,
-        __4,
-    )?;
+    let __temp0 = __action941(__1, __2, __3, __4)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action834(
-        __0,
-        __temp0,
-        __5,
-    )
+    __action834(__0, __temp0, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action959<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action959(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
@@ -45775,629 +41314,509 @@ fn __action959<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __6.2;
-    let __temp0 = __action942(
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )?;
+    let __temp0 = __action942(__1, __2, __3, __4, __5, __6)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action834(
-        __0,
-        __temp0,
-        __7,
-    )
+    __action834(__0, __temp0, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action960<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action960(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __5.2;
-    let __temp0 = __action943(
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )?;
+    let __temp0 = __action943(__1, __2, __3, __4, __5)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action834(
-        __0,
-        __temp0,
-        __6,
-    )
+    __action834(__0, __temp0, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action961<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action961(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action944(
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action944(__1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action834(
-        __0,
-        __temp0,
-        __4,
-    )
+    __action834(__0, __temp0, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action962<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action962(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action945(
-        __1,
-        __2,
-    )?;
+    let __temp0 = __action945(__1, __2)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action834(
-        __0,
-        __temp0,
-        __3,
-    )
+    __action834(__0, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action963<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action963(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action946(
-        __1,
-        __2,
-        __3,
-        __4,
-    )?;
+    let __temp0 = __action946(__1, __2, __3, __4)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action834(
-        __0,
-        __temp0,
-        __5,
-    )
+    __action834(__0, __temp0, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action964<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action964(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action947(
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action947(__1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action834(
-        __0,
-        __temp0,
-        __4,
-    )
+    __action834(__0, __temp0, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action965<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action965(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action397(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action397(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action834(
-        __0,
-        __temp0,
-        __1,
-    )
+    __action834(__0, __temp0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action966<
->(
+fn __action966(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
-) -> Option<Box<ast::Arg>>
-{
+) -> Option<Box<ast::Arg>> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action444(
-        __1,
-    );
+    let __temp0 = __action444(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action403(
-        __0,
-        __temp0,
-    )
+    __action403(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action967<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> Option<Box<ast::Arg>>
-{
+fn __action967(__0: (TextSize, token::Tok, TextSize)) -> Option<Box<ast::Arg>> {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action445(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action445(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action403(
-        __0,
-        __temp0,
-    )
+    __action403(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action968<
->(
+fn __action968(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action444(
-        __1,
-    );
+    let __temp0 = __action444(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action857(
-        __0,
-        __temp0,
-        __2,
-        __3,
-    )
+    __action857(__0, __temp0, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action969<
->(
+fn __action969(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action445(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action445(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action857(
-        __0,
-        __temp0,
-        __1,
-        __2,
-    )
+    __action857(__0, __temp0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action970<
->(
+fn __action970(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action444(
-        __1,
-    );
+    let __temp0 = __action444(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action858(
-        __0,
-        __temp0,
-        __2,
-        __3,
-        __4,
-    )
+    __action858(__0, __temp0, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action971<
->(
+fn __action971(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action445(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action445(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action858(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-    )
+    __action858(__0, __temp0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action972<
->(
+fn __action972(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action444(
-        __1,
-    );
+    let __temp0 = __action444(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action859(
-        __0,
-        __temp0,
-    )
+    __action859(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action973<
->(
+fn __action973(
     __0: (TextSize, token::Tok, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action445(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action445(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action859(
-        __0,
-        __temp0,
-    )
+    __action859(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action974<
->(
+fn __action974(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action444(
-        __1,
-    );
+    let __temp0 = __action444(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action860(
-        __0,
-        __temp0,
-        __2,
-    )
+    __action860(__0, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action975<
->(
+fn __action975(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action445(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action445(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action860(
-        __0,
-        __temp0,
-        __1,
-    )
+    __action860(__0, __temp0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action976<
->(
+fn __action976(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action968(
-        __1,
-        __2,
-        __3,
-        __4,
-    )?;
+    let __temp0 = __action968(__1, __2, __3, __4)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action406(
-        __0,
-        __temp0,
-    ))
+    Ok(__action406(__0, __temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action977<
->(
+fn __action977(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action969(
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action969(__1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action406(
-        __0,
-        __temp0,
-    ))
+    Ok(__action406(__0, __temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action978<
->(
+fn __action978(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.0;
     let __end0 = __5.2;
-    let __temp0 = __action970(
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )?;
+    let __temp0 = __action970(__1, __2, __3, __4, __5)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action406(
-        __0,
-        __temp0,
-    ))
+    Ok(__action406(__0, __temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action979<
->(
+fn __action979(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action971(
-        __1,
-        __2,
-        __3,
-        __4,
-    )?;
+    let __temp0 = __action971(__1, __2, __3, __4)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action406(
-        __0,
-        __temp0,
-    ))
+    Ok(__action406(__0, __temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action980<
->(
+fn __action980(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action972(
-        __1,
-        __2,
-    )?;
+    let __temp0 = __action972(__1, __2)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action406(
-        __0,
-        __temp0,
-    ))
+    Ok(__action406(__0, __temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action981<
->(
+fn __action981(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action973(
-        __1,
-    )?;
+    let __temp0 = __action973(__1)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action406(
-        __0,
-        __temp0,
-    ))
+    Ok(__action406(__0, __temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action982<
->(
+fn __action982(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action974(
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action974(__1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action406(
-        __0,
-        __temp0,
-    ))
+    Ok(__action406(__0, __temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action983<
->(
+fn __action983(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    (
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    ),
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action975(
-        __1,
-        __2,
-    )?;
+    let __temp0 = __action975(__1, __2)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action406(
-        __0,
-        __temp0,
-    ))
+    Ok(__action406(__0, __temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action984<
->(
+fn __action984(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action968(
-        __0,
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action968(__0, __1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action845(
-        __temp0,
-        __4,
-        __5,
-    ))
+    Ok(__action845(__temp0, __4, __5))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action985<
->(
+fn __action985(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action969(
-        __0,
-        __1,
-        __2,
-    )?;
+    let __temp0 = __action969(__0, __1, __2)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action845(
-        __temp0,
-        __3,
-        __4,
-    ))
+    Ok(__action845(__temp0, __3, __4))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action986<
->(
+fn __action986(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
@@ -46405,516 +41824,373 @@ fn __action986<
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __4.2;
-    let __temp0 = __action970(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )?;
+    let __temp0 = __action970(__0, __1, __2, __3, __4)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action845(
-        __temp0,
-        __5,
-        __6,
-    ))
+    Ok(__action845(__temp0, __5, __6))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action987<
->(
+fn __action987(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action971(
-        __0,
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action971(__0, __1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action845(
-        __temp0,
-        __4,
-        __5,
-    ))
+    Ok(__action845(__temp0, __4, __5))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action988<
->(
+fn __action988(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action972(
-        __0,
-        __1,
-    )?;
+    let __temp0 = __action972(__0, __1)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action845(
-        __temp0,
-        __2,
-        __3,
-    ))
+    Ok(__action845(__temp0, __2, __3))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action989<
->(
+fn __action989(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action973(
-        __0,
-    )?;
+    let __temp0 = __action973(__0)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action845(
-        __temp0,
-        __1,
-        __2,
-    ))
+    Ok(__action845(__temp0, __1, __2))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action990<
->(
+fn __action990(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action974(
-        __0,
-        __1,
-        __2,
-    )?;
+    let __temp0 = __action974(__0, __1, __2)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action845(
-        __temp0,
-        __3,
-        __4,
-    ))
+    Ok(__action845(__temp0, __3, __4))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action991<
->(
+fn __action991(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action975(
-        __0,
-        __1,
-    )?;
+    let __temp0 = __action975(__0, __1)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action845(
-        __temp0,
-        __2,
-        __3,
-    ))
+    Ok(__action845(__temp0, __2, __3))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action992<
->(
+fn __action992(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action968(
-        __0,
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action968(__0, __1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action846(
-        __temp0,
-        __4,
-    ))
+    Ok(__action846(__temp0, __4))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action993<
->(
+fn __action993(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action969(
-        __0,
-        __1,
-        __2,
-    )?;
+    let __temp0 = __action969(__0, __1, __2)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action846(
-        __temp0,
-        __3,
-    ))
+    Ok(__action846(__temp0, __3))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action994<
->(
+fn __action994(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __4.2;
-    let __temp0 = __action970(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )?;
+    let __temp0 = __action970(__0, __1, __2, __3, __4)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action846(
-        __temp0,
-        __5,
-    ))
+    Ok(__action846(__temp0, __5))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action995<
->(
+fn __action995(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action971(
-        __0,
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action971(__0, __1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action846(
-        __temp0,
-        __4,
-    ))
+    Ok(__action846(__temp0, __4))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action996<
->(
+fn __action996(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action972(
-        __0,
-        __1,
-    )?;
+    let __temp0 = __action972(__0, __1)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action846(
-        __temp0,
-        __2,
-    ))
+    Ok(__action846(__temp0, __2))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action997<
->(
+fn __action997(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action973(
-        __0,
-    )?;
+    let __temp0 = __action973(__0)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action846(
-        __temp0,
-        __1,
-    ))
+    Ok(__action846(__temp0, __1))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action998<
->(
+fn __action998(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action974(
-        __0,
-        __1,
-        __2,
-    )?;
+    let __temp0 = __action974(__0, __1, __2)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action846(
-        __temp0,
-        __3,
-    ))
+    Ok(__action846(__temp0, __3))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action999<
->(
+fn __action999(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action975(
-        __0,
-        __1,
-    )?;
+    let __temp0 = __action975(__0, __1)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action846(
-        __temp0,
-        __2,
-    ))
+    Ok(__action846(__temp0, __2))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1000<
->(
+fn __action1000(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    core::option::Option<(
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    )>,
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __4.2;
-    let __temp0 = __action976(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )?;
+    let __temp0 = __action976(__0, __1, __2, __3, __4)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action404(
-        __temp0,
-    ))
+    Ok(__action404(__temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1001<
->(
+fn __action1001(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    core::option::Option<(
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    )>,
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action977(
-        __0,
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action977(__0, __1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action404(
-        __temp0,
-    ))
+    Ok(__action404(__temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1002<
->(
+fn __action1002(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    core::option::Option<(
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    )>,
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __5.2;
-    let __temp0 = __action978(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )?;
+    let __temp0 = __action978(__0, __1, __2, __3, __4, __5)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action404(
-        __temp0,
-    ))
+    Ok(__action404(__temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1003<
->(
+fn __action1003(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    core::option::Option<(
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    )>,
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __4.2;
-    let __temp0 = __action979(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )?;
+    let __temp0 = __action979(__0, __1, __2, __3, __4)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action404(
-        __temp0,
-    ))
+    Ok(__action404(__temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1004<
->(
+fn __action1004(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
-) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    core::option::Option<(
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    )>,
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action980(
-        __0,
-        __1,
-        __2,
-    )?;
+    let __temp0 = __action980(__0, __1, __2)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action404(
-        __temp0,
-    ))
+    Ok(__action404(__temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1005<
->(
+fn __action1005(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    core::option::Option<(
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    )>,
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action981(
-        __0,
-        __1,
-    )?;
+    let __temp0 = __action981(__0, __1)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action404(
-        __temp0,
-    ))
+    Ok(__action404(__temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1006<
->(
+fn __action1006(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    core::option::Option<(
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    )>,
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action982(
-        __0,
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action982(__0, __1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action404(
-        __temp0,
-    ))
+    Ok(__action404(__temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1007<
->(
+fn __action1007(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<
+    core::option::Option<(
+        Option<Box<ast::Arg>>,
+        Vec<ast::ArgWithDefault>,
+        Option<Box<ast::Arg>>,
+    )>,
+    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action983(
-        __0,
-        __1,
-        __2,
-    )?;
+    let __temp0 = __action983(__0, __1, __2)?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action404(
-        __temp0,
-    ))
+    Ok(__action404(__temp0))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1008<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1008(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
@@ -46922,59 +42198,42 @@ fn __action1008<
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __5.2;
-    let __temp0 = __action1000(
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )?;
+    let __temp0 = __action1000(__1, __2, __3, __4, __5)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action841(
-        __0,
-        __temp0,
-        __6,
-        __7,
-    )
+    __action841(__0, __temp0, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1009<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1009(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action1001(
-        __1,
-        __2,
-        __3,
-        __4,
-    )?;
+    let __temp0 = __action1001(__1, __2, __3, __4)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action841(
-        __0,
-        __temp0,
-        __5,
-        __6,
-    )
+    __action841(__0, __temp0, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1010<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1010(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
@@ -46983,31 +42242,21 @@ fn __action1010<
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __6.2;
-    let __temp0 = __action1002(
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )?;
+    let __temp0 = __action1002(__1, __2, __3, __4, __5, __6)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action841(
-        __0,
-        __temp0,
-        __7,
-        __8,
-    )
+    __action841(__0, __temp0, __7, __8)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1011<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1011(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
@@ -47015,217 +42264,159 @@ fn __action1011<
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __5.2;
-    let __temp0 = __action1003(
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )?;
+    let __temp0 = __action1003(__1, __2, __3, __4, __5)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action841(
-        __0,
-        __temp0,
-        __6,
-        __7,
-    )
+    __action841(__0, __temp0, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1012<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1012(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action1004(
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action1004(__1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action841(
-        __0,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action841(__0, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1013<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1013(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1005(
-        __1,
-        __2,
-    )?;
+    let __temp0 = __action1005(__1, __2)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action841(
-        __0,
-        __temp0,
-        __3,
-        __4,
-    )
+    __action841(__0, __temp0, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1014<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1014(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action1006(
-        __1,
-        __2,
-        __3,
-        __4,
-    )?;
+    let __temp0 = __action1006(__1, __2, __3, __4)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action841(
-        __0,
-        __temp0,
-        __5,
-        __6,
-    )
+    __action841(__0, __temp0, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1015<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1015(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action1007(
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action1007(__1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action841(
-        __0,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action841(__0, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1016<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1016(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action405(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action405(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action841(
-        __0,
-        __temp0,
-        __1,
-        __2,
-    )
+    __action841(__0, __temp0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1017<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1017(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __5.2;
-    let __temp0 = __action1000(
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )?;
+    let __temp0 = __action1000(__1, __2, __3, __4, __5)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action842(
-        __0,
-        __temp0,
-        __6,
-    )
+    __action842(__0, __temp0, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1018<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1018(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action1001(
-        __1,
-        __2,
-        __3,
-        __4,
-    )?;
+    let __temp0 = __action1001(__1, __2, __3, __4)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action842(
-        __0,
-        __temp0,
-        __5,
-    )
+    __action842(__0, __temp0, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1019<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1019(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
@@ -47233,315 +42424,210 @@ fn __action1019<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __6.2;
-    let __temp0 = __action1002(
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )?;
+    let __temp0 = __action1002(__1, __2, __3, __4, __5, __6)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action842(
-        __0,
-        __temp0,
-        __7,
-    )
+    __action842(__0, __temp0, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1020<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1020(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __5.2;
-    let __temp0 = __action1003(
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )?;
+    let __temp0 = __action1003(__1, __2, __3, __4, __5)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action842(
-        __0,
-        __temp0,
-        __6,
-    )
+    __action842(__0, __temp0, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1021<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1021(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action1004(
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action1004(__1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action842(
-        __0,
-        __temp0,
-        __4,
-    )
+    __action842(__0, __temp0, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1022<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1022(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1005(
-        __1,
-        __2,
-    )?;
+    let __temp0 = __action1005(__1, __2)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action842(
-        __0,
-        __temp0,
-        __3,
-    )
+    __action842(__0, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1023<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1023(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action1006(
-        __1,
-        __2,
-        __3,
-        __4,
-    )?;
+    let __temp0 = __action1006(__1, __2, __3, __4)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action842(
-        __0,
-        __temp0,
-        __5,
-    )
+    __action842(__0, __temp0, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1024<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1024(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action1007(
-        __1,
-        __2,
-        __3,
-    )?;
+    let __temp0 = __action1007(__1, __2, __3)?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action842(
-        __0,
-        __temp0,
-        __4,
-    )
+    __action842(__0, __temp0, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1025<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1025(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action405(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action405(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action842(
-        __0,
-        __temp0,
-        __1,
-    )
+    __action842(__0, __temp0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1026<
->(
+fn __action1026(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> core::option::Option<ast::Expr>
-{
+) -> core::option::Option<ast::Expr> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action334(
-        __0,
-        __1,
-    );
+    let __temp0 = __action334(__0, __1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action332(
-        __temp0,
-    )
+    __action332(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1027<
->(
+fn __action1027(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __2.0;
     let __end0 = __3.2;
-    let __temp0 = __action1026(
-        __2,
-        __3,
-    );
+    let __temp0 = __action1026(__2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action692(
-        __0,
-        __1,
-        __temp0,
-        __4,
-    )
+    __action692(__0, __1, __temp0, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1028<
->(
+fn __action1028(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action333(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action333(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action692(
-        __0,
-        __1,
-        __temp0,
-        __2,
-    )
+    __action692(__0, __1, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1029<
->(
+fn __action1029(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<ast::Expr>
-{
+) -> alloc::vec::Vec<ast::Expr> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action527(
-        __0,
-        __1,
-    );
+    let __temp0 = __action527(__0, __1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action533(
-        __temp0,
-    )
+    __action533(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1030<
->(
+fn __action1030(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<ast::Expr>
-{
+) -> alloc::vec::Vec<ast::Expr> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action527(
-        __1,
-        __2,
-    );
+    let __temp0 = __action527(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action534(
-        __0,
-        __temp0,
-    )
+    __action534(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1031<
->(
+fn __action1031(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action525(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action525(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action700(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __3,
-        __4,
-        __5,
-    )
+    __action700(__0, __1, __2, __temp0, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1032<
->(
+fn __action1032(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -47549,111 +42635,63 @@ fn __action1032<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action526(
-        __3,
-    );
+    let __temp0 = __action526(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action700(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __4,
-        __5,
-        __6,
-    )
+    __action700(__0, __1, __2, __temp0, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1033<
->(
+fn __action1033(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action525(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action525(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action701(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __3,
-        __4,
-    )
+    __action701(__0, __1, __2, __temp0, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1034<
->(
+fn __action1034(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action526(
-        __3,
-    );
+    let __temp0 = __action526(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action701(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action701(__0, __1, __2, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1035<
->(
+fn __action1035(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action525(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action525(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action718(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __3,
-        __4,
-        __5,
-    )
+    __action718(__0, __1, __2, __temp0, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1036<
->(
+fn __action1036(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -47661,245 +42699,144 @@ fn __action1036<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action526(
-        __3,
-    );
+    let __temp0 = __action526(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action718(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __4,
-        __5,
-        __6,
-    )
+    __action718(__0, __1, __2, __temp0, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1037<
->(
+fn __action1037(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action525(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action525(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action719(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __3,
-        __4,
-    )
+    __action719(__0, __1, __2, __temp0, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1038<
->(
+fn __action1038(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action526(
-        __3,
-    );
+    let __temp0 = __action526(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action719(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action719(__0, __1, __2, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1039<
->(
+fn __action1039(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::WithItem, TextSize),
-) -> alloc::vec::Vec<ast::WithItem>
-{
+) -> alloc::vec::Vec<ast::WithItem> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action283(
-        __0,
-        __1,
-    );
+    let __temp0 = __action283(__0, __1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action277(
-        __temp0,
-    )
+    __action277(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1040<
->(
+fn __action1040(
     __0: (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::WithItem, TextSize),
-) -> alloc::vec::Vec<ast::WithItem>
-{
+) -> alloc::vec::Vec<ast::WithItem> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action283(
-        __1,
-        __2,
-    );
+    let __temp0 = __action283(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action278(
-        __0,
-        __temp0,
-    )
+    __action278(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1041<
->(
+fn __action1041(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::WithItem>>, TextSize),
     __2: (TextSize, ast::WithItem, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action281(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action281(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action627(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __3,
-        __4,
-    )
+    __action627(__0, __1, __2, __temp0, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1042<
->(
+fn __action1042(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::WithItem>>, TextSize),
     __2: (TextSize, ast::WithItem, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action282(
-        __3,
-    );
+    let __temp0 = __action282(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action627(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action627(__0, __1, __2, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1043<
->(
+fn __action1043(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::WithItem>>, TextSize),
     __2: (TextSize, ast::WithItem, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action281(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action281(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action628(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __3,
-    )
+    __action628(__0, __1, __2, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1044<
->(
+fn __action1044(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::WithItem>>, TextSize),
     __2: (TextSize, ast::WithItem, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action282(
-        __3,
-    );
+    let __temp0 = __action282(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action628(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __4,
-    )
+    __action628(__0, __1, __2, __temp0, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1045<
->(
+fn __action1045(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> core::option::Option<ast::Expr>
-{
+) -> core::option::Option<ast::Expr> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action272(
-        __0,
-        __1,
-    );
+    let __temp0 = __action272(__0, __1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action270(
-        __temp0,
-    )
+    __action270(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1046<
->(
+fn __action1046(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -47909,30 +42846,16 @@ fn __action1046<
     __6: (TextSize, ast::Expr, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __5.0;
     let __end0 = __6.2;
-    let __temp0 = __action1045(
-        __5,
-        __6,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action780(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-        __7,
-        __8,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1047<
->(
+    let __temp0 = __action1045(__5, __6);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action780(__0, __1, __2, __3, __4, __temp0, __7, __8)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1047(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -47940,30 +42863,16 @@ fn __action1047<
     __4: (TextSize, ast::Arguments, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __4.2;
     let __end0 = __5.0;
-    let __temp0 = __action271(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action780(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-        __5,
-        __6,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1048<
->(
+    let __temp0 = __action271(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action780(__0, __1, __2, __3, __4, __temp0, __5, __6)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1048(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
@@ -47972,478 +42881,288 @@ fn __action1048<
     __5: (TextSize, ast::Expr, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __4.0;
     let __end0 = __5.2;
-    let __temp0 = __action1045(
-        __4,
-        __5,
-    );
+    let __temp0 = __action1045(__4, __5);
     let __temp0 = (__start0, __temp0, __end0);
-    __action781(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __6,
-        __7,
-    )
+    __action781(__0, __1, __2, __3, __temp0, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1049<
->(
+fn __action1049(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, ast::Arguments, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action271(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action271(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action781(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action781(__0, __1, __2, __3, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1050<
->(
+fn __action1050(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Identifier, TextSize),
-) -> alloc::vec::Vec<(token::Tok, ast::Identifier)>
-{
+) -> alloc::vec::Vec<(token::Tok, ast::Identifier)> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action339(
-        __0,
-        __1,
-    );
+    let __temp0 = __action339(__0, __1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action337(
-        __temp0,
-    )
+    __action337(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1051<
->(
-    __0: (TextSize, alloc::vec::Vec<(token::Tok, ast::Identifier)>, TextSize),
+fn __action1051(
+    __0: (
+        TextSize,
+        alloc::vec::Vec<(token::Tok, ast::Identifier)>,
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> alloc::vec::Vec<(token::Tok, ast::Identifier)>
-{
+) -> alloc::vec::Vec<(token::Tok, ast::Identifier)> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action339(
-        __1,
-        __2,
-    );
+    let __temp0 = __action339(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action338(
-        __0,
-        __temp0,
-    )
+    __action338(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1052<
->(
+fn __action1052(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> core::option::Option<ast::Expr>
-{
+) -> core::option::Option<ast::Expr> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action262(
-        __0,
-        __1,
-    );
+    let __temp0 = __action262(__0, __1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action260(
-        __temp0,
-    )
+    __action260(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1053<
->(
+fn __action1053(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Arg
-{
+) -> ast::Arg {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1052(
-        __1,
-        __2,
-    );
+    let __temp0 = __action1052(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action762(
-        __0,
-        __temp0,
-        __3,
-    )
+    __action762(__0, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1054<
->(
+fn __action1054(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Arg
-{
+) -> ast::Arg {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action261(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action261(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action762(
-        __0,
-        __temp0,
-        __1,
-    )
+    __action762(__0, __temp0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1055<
->(
+fn __action1055(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::ArgWithDefault
-{
+) -> ast::ArgWithDefault {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1052(
-        __1,
-        __2,
-    );
+    let __temp0 = __action1052(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action900(
-        __0,
-        __temp0,
-        __3,
-    )
+    __action900(__0, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1056<
->(
+fn __action1056(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::ArgWithDefault
-{
+) -> ast::ArgWithDefault {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action261(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action261(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action900(
-        __0,
-        __temp0,
-        __1,
-    )
+    __action900(__0, __temp0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1057<
->(
+fn __action1057(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> core::option::Option<ast::Expr>
-{
+) -> core::option::Option<ast::Expr> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action259(
-        __0,
-        __1,
-    );
+    let __temp0 = __action259(__0, __1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action257(
-        __temp0,
-    )
+    __action257(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1058<
->(
+fn __action1058(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Arg
-{
+) -> ast::Arg {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1057(
-        __1,
-        __2,
-    );
+    let __temp0 = __action1057(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action883(
-        __0,
-        __temp0,
-        __3,
-    )
+    __action883(__0, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1059<
->(
+fn __action1059(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Arg
-{
+) -> ast::Arg {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action258(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action258(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action883(
-        __0,
-        __temp0,
-        __1,
-    )
+    __action883(__0, __temp0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1060<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<token::Tok>
-{
+fn __action1060(__0: (TextSize, token::Tok, TextSize)) -> alloc::vec::Vec<token::Tok> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action371(
-        __0,
-    );
+    let __temp0 = __action371(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action374(
-        __temp0,
-    )
+    __action374(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1061<
->(
+fn __action1061(
     __0: (TextSize, alloc::vec::Vec<token::Tok>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<token::Tok>
-{
+) -> alloc::vec::Vec<token::Tok> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action371(
-        __1,
-    );
+    let __temp0 = __action371(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action375(
-        __0,
-        __temp0,
-    )
+    __action375(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1062<
->(
+fn __action1062(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Mod
-{
+) -> ast::Mod {
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action369(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action369(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action896(
-        __0,
-        __1,
-        __temp0,
-        __2,
-    )
+    __action896(__0, __1, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1063<
->(
+fn __action1063(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<token::Tok>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Mod
-{
+) -> ast::Mod {
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action370(
-        __2,
-    );
+    let __temp0 = __action370(__2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action896(
-        __0,
-        __1,
-        __temp0,
-        __3,
-    )
+    __action896(__0, __1, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1064<
->(
+fn __action1064(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Identifier, TextSize),
-) -> core::option::Option<ast::Identifier>
-{
+) -> core::option::Option<ast::Identifier> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action382(
-        __0,
-        __1,
-    );
+    let __temp0 = __action382(__0, __1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action380(
-        __temp0,
-    )
+    __action380(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1065<
->(
+fn __action1065(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Alias
-{
+) -> ast::Alias {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1064(
-        __1,
-        __2,
-    );
+    let __temp0 = __action1064(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action792(
-        __0,
-        __temp0,
-        __3,
-    )
+    __action792(__0, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1066<
->(
+fn __action1066(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Alias
-{
+) -> ast::Alias {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action381(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action381(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action792(
-        __0,
-        __temp0,
-        __1,
-    )
+    __action792(__0, __temp0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1067<
->(
+fn __action1067(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Alias
-{
+) -> ast::Alias {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1064(
-        __1,
-        __2,
-    );
+    let __temp0 = __action1064(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action793(
-        __0,
-        __temp0,
-        __3,
-    )
+    __action793(__0, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1068<
->(
+fn __action1068(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Alias
-{
+) -> ast::Alias {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action381(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action381(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action793(
-        __0,
-        __temp0,
-        __1,
-    )
+    __action793(__0, __temp0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1069<
->(
+fn __action1069(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
-) -> core::option::Option<ast::Suite>
-{
+) -> core::option::Option<ast::Suite> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action304(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action304(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action302(
-        __temp0,
-    )
+    __action302(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1070<
->(
+fn __action1070(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -48454,31 +43173,16 @@ fn __action1070<
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, token::Tok, TextSize),
     __9: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __7.0;
     let __end0 = __9.2;
-    let __temp0 = __action1069(
-        __7,
-        __8,
-        __9,
-    );
+    let __temp0 = __action1069(__7, __8, __9);
     let __temp0 = (__start0, __temp0, __end0);
-    __action778(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __temp0,
-    )
+    __action778(__0, __1, __2, __3, __4, __5, __6, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1071<
->(
+fn __action1071(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -48486,30 +43190,16 @@ fn __action1071<
     __4: (TextSize, ast::Expr, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action303(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action303(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action778(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __temp0,
-    )
+    __action778(__0, __1, __2, __3, __4, __5, __6, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1072<
->(
+fn __action1072(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -48519,117 +43209,73 @@ fn __action1072<
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __6.0;
     let __end0 = __8.2;
-    let __temp0 = __action1069(
-        __6,
-        __7,
-        __8,
-    );
+    let __temp0 = __action1069(__6, __7, __8);
     let __temp0 = (__start0, __temp0, __end0);
-    __action779(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-    )
+    __action779(__0, __1, __2, __3, __4, __5, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1073<
->(
+fn __action1073(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action303(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action303(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action779(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-    )
+    __action779(__0, __1, __2, __3, __4, __5, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1074<
->(
+fn __action1074(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-    __4: (TextSize, alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>, TextSize),
+    __4: (
+        TextSize,
+        alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>,
+        TextSize,
+    ),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __5.0;
     let __end0 = __7.2;
-    let __temp0 = __action1069(
-        __5,
-        __6,
-        __7,
-    );
+    let __temp0 = __action1069(__5, __6, __7);
     let __temp0 = (__start0, __temp0, __end0);
-    __action791(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action791(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1075<
->(
+fn __action1075(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-    __4: (TextSize, alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>, TextSize),
-) -> ast::Stmt
-{
+    __4: (
+        TextSize,
+        alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>,
+        TextSize,
+    ),
+) -> ast::Stmt {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action303(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action303(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action791(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action791(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1076<
->(
+fn __action1076(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -48639,59 +43285,32 @@ fn __action1076<
     __6: (TextSize, ast::Suite, TextSize),
     __7: (TextSize, core::option::Option<ast::Suite>, TextSize),
     __8: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __4.0;
     let __end0 = __6.2;
-    let __temp0 = __action1069(
-        __4,
-        __5,
-        __6,
-    );
+    let __temp0 = __action1069(__4, __5, __6);
     let __temp0 = (__start0, __temp0, __end0);
-    __action897(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __7,
-        __8,
-    )
+    __action897(__0, __1, __2, __3, __temp0, __7, __8)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1077<
->(
+fn __action1077(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ExceptHandler>, TextSize),
     __4: (TextSize, core::option::Option<ast::Suite>, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action303(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action303(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action897(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action897(__0, __1, __2, __3, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1078<
->(
+fn __action1078(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -48701,59 +43320,32 @@ fn __action1078<
     __6: (TextSize, ast::Suite, TextSize),
     __7: (TextSize, core::option::Option<ast::Suite>, TextSize),
     __8: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __4.0;
     let __end0 = __6.2;
-    let __temp0 = __action1069(
-        __4,
-        __5,
-        __6,
-    );
+    let __temp0 = __action1069(__4, __5, __6);
     let __temp0 = (__start0, __temp0, __end0);
-    __action898(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __7,
-        __8,
-    )
+    __action898(__0, __1, __2, __3, __temp0, __7, __8)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1079<
->(
+fn __action1079(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ExceptHandler>, TextSize),
     __4: (TextSize, core::option::Option<ast::Suite>, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action303(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action303(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action898(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action898(__0, __1, __2, __3, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1080<
->(
+fn __action1080(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -48761,101 +43353,59 @@ fn __action1080<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __4.0;
     let __end0 = __6.2;
-    let __temp0 = __action1069(
-        __4,
-        __5,
-        __6,
-    );
+    let __temp0 = __action1069(__4, __5, __6);
     let __temp0 = (__start0, __temp0, __end0);
-    __action903(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action903(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1081<
->(
+fn __action1081(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action303(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action303(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action903(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action903(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1082<
->(
+fn __action1082(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
-) -> core::option::Option<ast::Suite>
-{
+) -> core::option::Option<ast::Suite> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action297(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action297(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action295(
-        __temp0,
-    )
+    __action295(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1083<
->(
+fn __action1083(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __3.0;
     let __end0 = __5.2;
-    let __temp0 = __action297(
-        __3,
-        __4,
-        __5,
-    );
+    let __temp0 = __action297(__3, __4, __5);
     let __temp0 = (__start0, __temp0, __end0);
-    __action899(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action899(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1084<
->(
+fn __action1084(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -48867,32 +43417,16 @@ fn __action1084<
     __8: (TextSize, token::Tok, TextSize),
     __9: (TextSize, ast::Suite, TextSize),
     __10: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __7.0;
     let __end0 = __9.2;
-    let __temp0 = __action1082(
-        __7,
-        __8,
-        __9,
-    );
+    let __temp0 = __action1082(__7, __8, __9);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1076(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __temp0,
-        __10,
-    )
+    __action1076(__0, __1, __2, __3, __4, __5, __6, __temp0, __10)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1085<
->(
+fn __action1085(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -48901,31 +43435,16 @@ fn __action1085<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __6.2;
     let __end0 = __7.0;
-    let __temp0 = __action296(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action296(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1076(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __temp0,
-        __7,
-    )
+    __action1076(__0, __1, __2, __3, __4, __5, __6, __temp0, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1086<
->(
+fn __action1086(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -48934,56 +43453,31 @@ fn __action1086<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __4.0;
     let __end0 = __6.2;
-    let __temp0 = __action1082(
-        __4,
-        __5,
-        __6,
-    );
+    let __temp0 = __action1082(__4, __5, __6);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1077(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __7,
-    )
+    __action1077(__0, __1, __2, __3, __temp0, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1087<
->(
+fn __action1087(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ExceptHandler>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action296(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action296(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1077(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __4,
-    )
+    __action1077(__0, __1, __2, __3, __temp0, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1088<
->(
+fn __action1088(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -48995,32 +43489,16 @@ fn __action1088<
     __8: (TextSize, token::Tok, TextSize),
     __9: (TextSize, ast::Suite, TextSize),
     __10: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __7.0;
     let __end0 = __9.2;
-    let __temp0 = __action1082(
-        __7,
-        __8,
-        __9,
-    );
+    let __temp0 = __action1082(__7, __8, __9);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1078(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __temp0,
-        __10,
-    )
+    __action1078(__0, __1, __2, __3, __4, __5, __6, __temp0, __10)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1089<
->(
+fn __action1089(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -49029,31 +43507,16 @@ fn __action1089<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __6.2;
     let __end0 = __7.0;
-    let __temp0 = __action296(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action296(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1078(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __temp0,
-        __7,
-    )
+    __action1078(__0, __1, __2, __3, __4, __5, __6, __temp0, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1090<
->(
+fn __action1090(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -49062,171 +43525,104 @@ fn __action1090<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __4.0;
     let __end0 = __6.2;
-    let __temp0 = __action1082(
-        __4,
-        __5,
-        __6,
-    );
+    let __temp0 = __action1082(__4, __5, __6);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1079(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __7,
-    )
+    __action1079(__0, __1, __2, __3, __temp0, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1091<
->(
+fn __action1091(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ExceptHandler>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action296(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action296(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1079(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __4,
-    )
+    __action1079(__0, __1, __2, __3, __temp0, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1092<
->(
+fn __action1092(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> core::option::Option<ast::Expr>
-{
+) -> core::option::Option<ast::Expr> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action354(
-        __0,
-        __1,
-    );
+    let __temp0 = __action354(__0, __1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action352(
-        __temp0,
-    )
+    __action352(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1093<
->(
+fn __action1093(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __2.0;
     let __end0 = __3.2;
-    let __temp0 = __action1092(
-        __2,
-        __3,
-    );
+    let __temp0 = __action1092(__2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action869(
-        __0,
-        __1,
-        __temp0,
-        __4,
-    )
+    __action869(__0, __1, __temp0, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1094<
->(
+fn __action1094(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action353(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action353(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action869(
-        __0,
-        __1,
-        __temp0,
-        __2,
-    )
+    __action869(__0, __1, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1095<
->(
+fn __action1095(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>
-{
+) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action682(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action682(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action387(
-        __temp0,
-    )
+    __action387(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1096<
->(
-    __0: (TextSize, alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>, TextSize),
+fn __action1096(
+    __0: (
+        TextSize,
+        alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>,
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Suite, TextSize),
-) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>
-{
+) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)> {
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action682(
-        __1,
-        __2,
-        __3,
-        __4,
-    );
+    let __temp0 = __action682(__1, __2, __3, __4);
     let __temp0 = (__start0, __temp0, __end0);
-    __action388(
-        __0,
-        __temp0,
-    )
+    __action388(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1097<
->(
+fn __action1097(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49234,288 +43630,235 @@ fn __action1097<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action305(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action305(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1074(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __4,
-        __5,
-        __6,
-    )
+    __action1074(__0, __1, __2, __3, __temp0, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1098<
->(
+fn __action1098(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-    __4: (TextSize, alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>, TextSize),
+    __4: (
+        TextSize,
+        alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>,
+        TextSize,
+    ),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action306(
-        __4,
-    );
+    let __temp0 = __action306(__4);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1074(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __5,
-        __6,
-        __7,
-    )
+    __action1074(__0, __1, __2, __3, __temp0, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1099<
->(
+fn __action1099(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action305(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action305(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1075(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action1075(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1100<
->(
+fn __action1100(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-    __4: (TextSize, alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>, TextSize),
-) -> ast::Stmt
-{
+    __4: (
+        TextSize,
+        alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>,
+        TextSize,
+    ),
+) -> ast::Stmt {
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action306(
-        __4,
-    );
+    let __temp0 = __action306(__4);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1075(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action1075(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1101<
->(
+fn __action1101(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<ast::Expr>
-{
+) -> alloc::vec::Vec<ast::Expr> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action416(
-        __0,
-        __1,
-    );
+    let __temp0 = __action416(__0, __1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action414(
-        __temp0,
-    )
+    __action414(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1102<
->(
+fn __action1102(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<ast::Expr>
-{
+) -> alloc::vec::Vec<ast::Expr> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action416(
-        __1,
-        __2,
-    );
+    let __temp0 = __action416(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action415(
-        __0,
-        __temp0,
-    )
+    __action415(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1103<
->(
-    __0: (TextSize, (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr), TextSize),
+fn __action1103(
+    __0: (
+        TextSize,
+        (
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        ),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
-{
+) -> alloc::vec::Vec<(
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+)> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action425(
-        __0,
-        __1,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action426(
-        __temp0,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1104<
->(
-    __0: (TextSize, alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
-    __1: (TextSize, (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr), TextSize),
-    __2: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
-{
+    let __temp0 = __action425(__0, __1);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action426(__temp0)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1104(
+    __0: (
+        TextSize,
+        alloc::vec::Vec<(
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        )>,
+        TextSize,
+    ),
+    __1: (
+        TextSize,
+        (
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        ),
+        TextSize,
+    ),
+    __2: (TextSize, token::Tok, TextSize),
+) -> alloc::vec::Vec<(
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+)> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action425(
-        __1,
-        __2,
-    );
+    let __temp0 = __action425(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action427(
-        __0,
-        __temp0,
-    )
+    __action427(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1105<
->(
-    __0: (TextSize, core::option::Option<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
-) -> Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
-{
+fn __action1105(
+    __0: (
+        TextSize,
+        core::option::Option<(
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        )>,
+        TextSize,
+    ),
+) -> Vec<(
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+)> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action423(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action227(
-        __temp0,
-        __0,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1106<
->(
-    __0: (TextSize, alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
-    __1: (TextSize, core::option::Option<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
-) -> Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
-{
+    let __temp0 = __action423(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action227(__temp0, __0)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1106(
+    __0: (
+        TextSize,
+        alloc::vec::Vec<(
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        )>,
+        TextSize,
+    ),
+    __1: (
+        TextSize,
+        core::option::Option<(
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        )>,
+        TextSize,
+    ),
+) -> Vec<(
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+)> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action424(
-        __0,
-    );
+    let __temp0 = __action424(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action227(
-        __temp0,
-        __1,
-    )
+    __action227(__temp0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1107<
->(
+fn __action1107(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<ast::Expr>
-{
+) -> alloc::vec::Vec<ast::Expr> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action430(
-        __0,
-        __1,
-    );
+    let __temp0 = __action430(__0, __1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action428(
-        __temp0,
-    )
+    __action428(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1108<
->(
+fn __action1108(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<ast::Expr>
-{
+) -> alloc::vec::Vec<ast::Expr> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action430(
-        __1,
-        __2,
-    );
+    let __temp0 = __action430(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action429(
-        __0,
-        __temp0,
-    )
+    __action429(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1109<
->(
+fn __action1109(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> core::option::Option<Vec<ast::Expr>>
-{
+) -> core::option::Option<Vec<ast::Expr>> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action530(
-        __0,
-        __1,
-    );
+    let __temp0 = __action530(__0, __1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action528(
-        __temp0,
-    )
+    __action528(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1110<
->(
+fn __action1110(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49523,55 +43866,31 @@ fn __action1110<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1109(
-        __1,
-        __2,
-    );
+    let __temp0 = __action1109(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1031(
-        __0,
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action1031(__0, __temp0, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1111<
->(
+fn __action1111(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action529(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action529(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1031(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action1031(__0, __temp0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1112<
->(
+fn __action1112(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49580,110 +43899,62 @@ fn __action1112<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1109(
-        __1,
-        __2,
-    );
+    let __temp0 = __action1109(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1032(
-        __0,
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action1032(__0, __temp0, __3, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1113<
->(
+fn __action1113(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action529(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action529(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1032(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action1032(__0, __temp0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1114<
->(
+fn __action1114(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1109(
-        __1,
-        __2,
-    );
+    let __temp0 = __action1109(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1033(
-        __0,
-        __temp0,
-        __3,
-        __4,
-        __5,
-    )
+    __action1033(__0, __temp0, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1115<
->(
+fn __action1115(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action529(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action529(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1033(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-    )
+    __action1033(__0, __temp0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1116<
->(
+fn __action1116(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49691,55 +43962,31 @@ fn __action1116<
     __4: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1109(
-        __1,
-        __2,
-    );
+    let __temp0 = __action1109(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1034(
-        __0,
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action1034(__0, __temp0, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1117<
->(
+fn __action1117(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action529(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action529(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1034(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action1034(__0, __temp0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1118<
->(
+fn __action1118(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49747,55 +43994,31 @@ fn __action1118<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1109(
-        __1,
-        __2,
-    );
+    let __temp0 = __action1109(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1035(
-        __0,
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action1035(__0, __temp0, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1119<
->(
+fn __action1119(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action529(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action529(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1035(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action1035(__0, __temp0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1120<
->(
+fn __action1120(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49804,110 +44027,62 @@ fn __action1120<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1109(
-        __1,
-        __2,
-    );
+    let __temp0 = __action1109(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1036(
-        __0,
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action1036(__0, __temp0, __3, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1121<
->(
+fn __action1121(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action529(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action529(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1036(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action1036(__0, __temp0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1122<
->(
+fn __action1122(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1109(
-        __1,
-        __2,
-    );
+    let __temp0 = __action1109(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1037(
-        __0,
-        __temp0,
-        __3,
-        __4,
-        __5,
-    )
+    __action1037(__0, __temp0, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1123<
->(
+fn __action1123(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action529(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action529(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1037(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-    )
+    __action1037(__0, __temp0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1124<
->(
+fn __action1124(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49915,568 +44090,336 @@ fn __action1124<
     __4: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1109(
-        __1,
-        __2,
-    );
+    let __temp0 = __action1109(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1038(
-        __0,
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action1038(__0, __temp0, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1125<
->(
+fn __action1125(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action529(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action529(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1038(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action1038(__0, __temp0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1126<
->(
+fn __action1126(
     __0: (TextSize, ast::Pattern, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<ast::Pattern>
-{
+) -> alloc::vec::Vec<ast::Pattern> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action320(
-        __0,
-        __1,
-    );
+    let __temp0 = __action320(__0, __1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action318(
-        __temp0,
-    )
+    __action318(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1127<
->(
+fn __action1127(
     __0: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     __1: (TextSize, ast::Pattern, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<ast::Pattern>
-{
+) -> alloc::vec::Vec<ast::Pattern> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action320(
-        __1,
-        __2,
-    );
+    let __temp0 = __action320(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action319(
-        __0,
-        __temp0,
-    )
+    __action319(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1128<
->(
+fn __action1128(
     __0: (TextSize, core::option::Option<ast::Pattern>, TextSize),
-) -> Vec<ast::Pattern>
-{
+) -> Vec<ast::Pattern> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action385(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action385(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action317(
-        __temp0,
-        __0,
-    )
+    __action317(__temp0, __0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1129<
->(
+fn __action1129(
     __0: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     __1: (TextSize, core::option::Option<ast::Pattern>, TextSize),
-) -> Vec<ast::Pattern>
-{
+) -> Vec<ast::Pattern> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action386(
-        __0,
-    );
+    let __temp0 = __action386(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action317(
-        __temp0,
-        __1,
-    )
+    __action317(__temp0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1130<
->(
+fn __action1130(
     __0: (TextSize, ast::Stmt, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<ast::Stmt>
-{
+) -> alloc::vec::Vec<ast::Stmt> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action368(
-        __0,
-        __1,
-    );
+    let __temp0 = __action368(__0, __1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action376(
-        __temp0,
-    )
+    __action376(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1131<
->(
+fn __action1131(
     __0: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<ast::Stmt>
-{
+) -> alloc::vec::Vec<ast::Stmt> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action368(
-        __1,
-        __2,
-    );
+    let __temp0 = __action368(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action377(
-        __0,
-        __temp0,
-    )
+    __action377(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1132<
->(
+fn __action1132(
     __0: (TextSize, ast::Suite, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Suite
-{
+) -> ast::Suite {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action366(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action366(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action629(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-    )
+    __action629(__0, __temp0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1133<
->(
+fn __action1133(
     __0: (TextSize, ast::Suite, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __2: (TextSize, ast::Stmt, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> ast::Suite
-{
+) -> ast::Suite {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action367(
-        __1,
-    );
+    let __temp0 = __action367(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action629(
-        __0,
-        __temp0,
-        __2,
-        __3,
-        __4,
-    )
+    __action629(__0, __temp0, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1134<
->(
+fn __action1134(
     __0: (TextSize, ast::Suite, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Suite
-{
+) -> ast::Suite {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action366(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action366(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action630(
-        __0,
-        __temp0,
-        __1,
-        __2,
-    )
+    __action630(__0, __temp0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1135<
->(
+fn __action1135(
     __0: (TextSize, ast::Suite, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __2: (TextSize, ast::Stmt, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Suite
-{
+) -> ast::Suite {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action367(
-        __1,
-    );
+    let __temp0 = __action367(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action630(
-        __0,
-        __temp0,
-        __2,
-        __3,
-    )
+    __action630(__0, __temp0, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1136<
->(
+fn __action1136(
     __0: (TextSize, ast::Stmt, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt>
-{
+) -> Vec<ast::Stmt> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action366(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action366(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action631(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action631(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1137<
->(
+fn __action1137(
     __0: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt>
-{
+) -> Vec<ast::Stmt> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action367(
-        __0,
-    );
+    let __temp0 = __action367(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action631(
-        __temp0,
-        __1,
-        __2,
-        __3,
-    )
+    __action631(__temp0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1138<
->(
+fn __action1138(
     __0: (TextSize, ast::Stmt, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt>
-{
+) -> Vec<ast::Stmt> {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action366(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action366(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action632(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action632(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1139<
->(
+fn __action1139(
     __0: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt>
-{
+) -> Vec<ast::Stmt> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action367(
-        __0,
-    );
+    let __temp0 = __action367(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action632(
-        __temp0,
-        __1,
-        __2,
-    )
+    __action632(__temp0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1140<
->(
+fn __action1140(
     __0: (TextSize, Vec<ast::Stmt>, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt>
-{
+) -> Vec<ast::Stmt> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action366(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action366(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action633(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-    )
+    __action633(__0, __temp0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1141<
->(
+fn __action1141(
     __0: (TextSize, Vec<ast::Stmt>, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __2: (TextSize, ast::Stmt, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt>
-{
+) -> Vec<ast::Stmt> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action367(
-        __1,
-    );
+    let __temp0 = __action367(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action633(
-        __0,
-        __temp0,
-        __2,
-        __3,
-        __4,
-    )
+    __action633(__0, __temp0, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1142<
->(
+fn __action1142(
     __0: (TextSize, Vec<ast::Stmt>, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt>
-{
+) -> Vec<ast::Stmt> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action366(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action366(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action634(
-        __0,
-        __temp0,
-        __1,
-        __2,
-    )
+    __action634(__0, __temp0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1143<
->(
+fn __action1143(
     __0: (TextSize, Vec<ast::Stmt>, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __2: (TextSize, ast::Stmt, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt>
-{
+) -> Vec<ast::Stmt> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action367(
-        __1,
-    );
+    let __temp0 = __action367(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action634(
-        __0,
-        __temp0,
-        __2,
-        __3,
-    )
+    __action634(__0, __temp0, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1144<
->(
+fn __action1144(
     __0: (TextSize, ast::Stmt, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Suite
-{
+) -> ast::Suite {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action366(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action366(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action635(
-        __temp0,
-        __0,
-        __1,
-        __2,
-    )
+    __action635(__temp0, __0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1145<
->(
+fn __action1145(
     __0: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Suite
-{
+) -> ast::Suite {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action367(
-        __0,
-    );
+    let __temp0 = __action367(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action635(
-        __temp0,
-        __1,
-        __2,
-        __3,
-    )
+    __action635(__temp0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1146<
->(
+fn __action1146(
     __0: (TextSize, ast::Stmt, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Suite
-{
+) -> ast::Suite {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action366(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action366(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action636(
-        __temp0,
-        __0,
-        __1,
-    )
+    __action636(__temp0, __0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1147<
->(
+fn __action1147(
     __0: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Suite
-{
+) -> ast::Suite {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action367(
-        __0,
-    );
+    let __temp0 = __action367(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action636(
-        __temp0,
-        __1,
-        __2,
-    )
+    __action636(__temp0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1148<
->(
+fn __action1148(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Identifier, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler
-{
+) -> ast::ExceptHandler {
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action292(
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action292(__1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action764(
-        __0,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action764(__0, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1149<
->(
+fn __action1149(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -50484,461 +44427,257 @@ fn __action1149<
     __4: (TextSize, ast::Identifier, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler
-{
+) -> ast::ExceptHandler {
     let __start0 = __2.0;
     let __end0 = __4.2;
-    let __temp0 = __action292(
-        __2,
-        __3,
-        __4,
-    );
+    let __temp0 = __action292(__2, __3, __4);
     let __temp0 = (__start0, __temp0, __end0);
-    __action766(
-        __0,
-        __1,
-        __temp0,
-        __5,
-        __6,
-    )
+    __action766(__0, __1, __temp0, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1150<
->(
+fn __action1150(
     __0: (TextSize, (String, StringKind, bool), TextSize),
-) -> (TextSize, (String, StringKind, bool), TextSize)
-{
+) -> (TextSize, (String, StringKind, bool), TextSize) {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action683(
-        __0,
-        __temp0,
-    )
+    __action683(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1151<
->(
+fn __action1151(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action684(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action684(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1152<
->(
+fn __action1152(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action685(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action685(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1153<
->(
+fn __action1153(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action686(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action686(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1154<
->(
+fn __action1154(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action687(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action687(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1155<
->(
+fn __action1155(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action688(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action688(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1156<
->(
+fn __action1156(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action689(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action689(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1157<
->(
+fn __action1157(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action690(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action690(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1158<
->(
+fn __action1158(
     __0: (TextSize, ast::Pattern, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> Result<ast::Pattern,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Pattern, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action691(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action691(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1159<
->(
+fn __action1159(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1027(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action1027(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1160<
->(
+fn __action1160(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1028(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action1028(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1161<
->(
-    __0: (TextSize, ast::Constant, TextSize),
-) -> ast::Expr
-{
+fn __action1161(__0: (TextSize, ast::Constant, TextSize)) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action694(
-        __0,
-        __temp0,
-    )
+    __action694(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1162<
->(
-    __0: (TextSize, ast::Identifier, TextSize),
-) -> ast::Expr
-{
+fn __action1162(__0: (TextSize, ast::Identifier, TextSize)) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action695(
-        __0,
-        __temp0,
-    )
+    __action695(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1163<
->(
+fn __action1163(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action696(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action696(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1164<
->(
+fn __action1164(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action697(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action697(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1165<
->(
+fn __action1165(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action698(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action698(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1166<
->(
+fn __action1166(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action699(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action699(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1167<
->(
+fn __action1167(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1110(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-    )
+    __action1110(__0, __1, __2, __3, __4, __5, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1168<
->(
+fn __action1168(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1111(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action1111(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1169<
->(
+fn __action1169(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50946,544 +44685,298 @@ fn __action1169<
     __4: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1112(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __temp0,
-    )
+    __action1112(__0, __1, __2, __3, __4, __5, __6, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1170<
->(
+fn __action1170(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1113(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action1113(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1171<
->(
+fn __action1171(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1114(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action1114(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1172<
->(
+fn __action1172(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1115(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action1115(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1173<
->(
+fn __action1173(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1116(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-    )
+    __action1116(__0, __1, __2, __3, __4, __5, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1174<
->(
+fn __action1174(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1117(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action1117(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1175<
->(
+fn __action1175(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action702(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action702(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1176<
->(
+fn __action1176(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action703(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action703(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1177<
->(
+fn __action1177(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action704(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action704(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1178<
->(
+fn __action1178(
     __0: (TextSize, token::Tok, TextSize),
-    __1: (TextSize, core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>, TextSize),
+    __1: (
+        TextSize,
+        core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>,
+        TextSize,
+    ),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action705(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action705(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1179<
->(
+fn __action1179(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, (ast::Expr, ast::Expr), TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action706(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action706(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1180<
->(
+fn __action1180(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action707(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action707(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1181<
->(
+fn __action1181(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action708(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action708(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1182<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+fn __action1182(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action709(
-        __0,
-        __temp0,
-    )
+    __action709(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1183<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+fn __action1183(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action710(
-        __0,
-        __temp0,
-    )
+    __action710(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1184<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+fn __action1184(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action711(
-        __0,
-        __temp0,
-    )
+    __action711(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1185<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+fn __action1185(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action712(
-        __0,
-        __temp0,
-    )
+    __action712(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1186<
->(
-    __0: (TextSize, ast::Constant, TextSize),
-) -> ast::Expr
-{
+fn __action1186(__0: (TextSize, ast::Constant, TextSize)) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action714(
-        __0,
-        __temp0,
-    )
+    __action714(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1187<
->(
-    __0: (TextSize, ast::Identifier, TextSize),
-) -> ast::Expr
-{
+fn __action1187(__0: (TextSize, ast::Identifier, TextSize)) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action715(
-        __0,
-        __temp0,
-    )
+    __action715(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1188<
->(
+fn __action1188(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action716(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action716(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1189<
->(
+fn __action1189(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action717(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action717(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1190<
->(
+fn __action1190(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1118(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-    )
+    __action1118(__0, __1, __2, __3, __4, __5, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1191<
->(
+fn __action1191(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1119(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action1119(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1192<
->(
+fn __action1192(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -51491,611 +44984,338 @@ fn __action1192<
     __4: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1120(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __temp0,
-    )
+    __action1120(__0, __1, __2, __3, __4, __5, __6, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1193<
->(
+fn __action1193(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1121(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action1121(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1194<
->(
+fn __action1194(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1122(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action1122(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1195<
->(
+fn __action1195(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1123(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action1123(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1196<
->(
+fn __action1196(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1124(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-    )
+    __action1124(__0, __1, __2, __3, __4, __5, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1197<
->(
+fn __action1197(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1125(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action1125(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1198<
->(
+fn __action1198(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action720(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action720(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1199<
->(
+fn __action1199(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action721(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action721(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1200<
->(
+fn __action1200(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action722(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action722(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1201<
->(
+fn __action1201(
     __0: (TextSize, token::Tok, TextSize),
-    __1: (TextSize, core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>, TextSize),
+    __1: (
+        TextSize,
+        core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>,
+        TextSize,
+    ),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action723(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action723(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1202<
->(
+fn __action1202(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, (ast::Expr, ast::Expr), TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action724(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action724(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1203<
->(
+fn __action1203(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action725(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action725(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1204<
->(
+fn __action1204(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action726(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action726(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1205<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+fn __action1205(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action727(
-        __0,
-        __temp0,
-    )
+    __action727(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1206<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+fn __action1206(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action728(
-        __0,
-        __temp0,
-    )
+    __action728(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1207<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+fn __action1207(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action729(
-        __0,
-        __temp0,
-    )
+    __action729(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1208<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+fn __action1208(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action730(
-        __0,
-        __temp0,
-    )
+    __action730(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1209<
->(
+fn __action1209(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ArgumentList, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action731(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action731(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1210<
->(
+fn __action1210(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action732(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action732(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1211<
->(
+fn __action1211(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action733(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action733(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1212<
->(
+fn __action1212(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ArgumentList, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action734(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action734(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1213<
->(
+fn __action1213(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action735(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action735(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1214<
->(
+fn __action1214(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action736(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action736(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1215<
->(
+fn __action1215(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action737(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action737(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1216<
->(
+fn __action1216(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action738(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action738(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1217<
->(
-    __0: (TextSize, ast::Identifier, TextSize),
-) -> ast::Pattern
-{
+fn __action1217(__0: (TextSize, ast::Identifier, TextSize)) -> ast::Pattern {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action739(
-        __0,
-        __temp0,
-    )
+    __action739(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1218<
->(
+fn __action1218(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
@@ -52103,186 +45323,103 @@ fn __action1218<
     __4: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action742(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __temp0,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1219<
->(
+    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action742(__0, __1, __2, __3, __4, __5, __6, __temp0)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1219(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action743(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-    )
+    __action743(__0, __1, __2, __3, __4, __5, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1220<
->(
+fn __action1220(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action744(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action744(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1221<
->(
+fn __action1221(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action745(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action745(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1222<
->(
+fn __action1222(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action746(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action746(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1223<
->(
+fn __action1223(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action747(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action747(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1224<
->(
+fn __action1224(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action748(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action748(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1225<
->(
+fn __action1225(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
@@ -52290,1286 +45427,717 @@ fn __action1225<
     __4: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action749(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __temp0,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1226<
->(
+    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action749(__0, __1, __2, __3, __4, __5, __6, __temp0)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1226(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action750(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-    )
+    __action750(__0, __1, __2, __3, __4, __5, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1227<
->(
+fn __action1227(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action751(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action751(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1228<
->(
+fn __action1228(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action752(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action752(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1229<
->(
+fn __action1229(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action753(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action753(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1230<
->(
+fn __action1230(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action754(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action754(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1231<
->(
+fn __action1231(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action755(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action755(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1232<
->(
+fn __action1232(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, alloc::vec::Vec<(ast::CmpOp, ast::Expr)>, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action756(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action756(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1233<
->(
+fn __action1233(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, alloc::vec::Vec<(ast::CmpOp, ast::Expr)>, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action757(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action757(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1234<
->(
-    __0: (TextSize, ast::Constant, TextSize),
-) -> ast::Expr
-{
+fn __action1234(__0: (TextSize, ast::Constant, TextSize)) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action758(
-        __0,
-        __temp0,
-    )
+    __action758(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1235<
->(
+fn __action1235(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action759(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action759(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1236<
->(
+fn __action1236(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action761(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action761(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1237<
->(
+fn __action1237(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Arg
-{
+) -> ast::Arg {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1053(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action1053(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1238<
->(
-    __0: (TextSize, ast::Identifier, TextSize),
-) -> ast::Arg
-{
+fn __action1238(__0: (TextSize, ast::Identifier, TextSize)) -> ast::Arg {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1054(
-        __0,
-        __temp0,
-    )
+    __action1054(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1239<
->(
+fn __action1239(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action767(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action767(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1240<
->(
+fn __action1240(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action768(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action768(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1241<
->(
+fn __action1241(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action769(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action769(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1242<
->(
+fn __action1242(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action770(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action770(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1243<
->(
+fn __action1243(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, core::option::Option<ast::Expr>, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action771(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action771(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1244<
->(
+fn __action1244(
     __0: (TextSize, ast::UnaryOp, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action772(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action772(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1245<
->(
+fn __action1245(
     __0: (TextSize, ast::UnaryOp, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action773(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action773(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1246<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> ast::Stmt
-{
+fn __action1246(__0: (TextSize, token::Tok, TextSize)) -> ast::Stmt {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action774(
-        __0,
-        __temp0,
-    )
+    __action774(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1247<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> ast::Stmt
-{
+fn __action1247(__0: (TextSize, token::Tok, TextSize)) -> ast::Stmt {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action775(
-        __0,
-        __temp0,
-    )
+    __action775(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1248<
->(
+fn __action1248(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Expr>, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action776(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action776(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1249<
->(
-    __0: (TextSize, ast::Expr, TextSize),
-) -> ast::Stmt
-{
+fn __action1249(__0: (TextSize, ast::Expr, TextSize)) -> ast::Stmt {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action777(
-        __0,
-        __temp0,
-    )
+    __action777(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1250<
->(
+fn __action1250(
     __0: (TextSize, ast::Expr, TextSize),
-    __1: (TextSize, core::option::Option<Vec<ast::Comprehension>>, TextSize),
-) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
-{
+    __1: (
+        TextSize,
+        core::option::Option<Vec<ast::Comprehension>>,
+        TextSize,
+    ),
+) -> (
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+) {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action782(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action782(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1251<
->(
+fn __action1251(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
-{
+) -> (
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+) {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action783(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action783(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1252<
->(
+fn __action1252(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
-{
+) -> (
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+) {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action784(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action784(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1253<
->(
+fn __action1253(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
-{
+) -> (
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+) {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action785(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action785(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1254<
->(
+fn __action1254(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action786(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action786(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1255<
->(
-    __0: (TextSize, Vec<ast::Expr>, TextSize),
-) -> ast::Expr
-{
+fn __action1255(__0: (TextSize, Vec<ast::Expr>, TextSize)) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action787(
-        __0,
-        __temp0,
-    )
+    __action787(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1256<
->(
+fn __action1256(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action788(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action788(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1257<
->(
-    __0: (TextSize, Vec<ast::Expr>, TextSize),
-) -> ast::Expr
-{
+fn __action1257(__0: (TextSize, Vec<ast::Expr>, TextSize)) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action789(
-        __0,
-        __temp0,
-    )
+    __action789(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1258<
->(
+fn __action1258(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Identifier>, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action790(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action790(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1259<
->(
+fn __action1259(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> ast::Alias
-{
+) -> ast::Alias {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1065(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action1065(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1260<
->(
-    __0: (TextSize, ast::Identifier, TextSize),
-) -> ast::Alias
-{
+fn __action1260(__0: (TextSize, ast::Identifier, TextSize)) -> ast::Alias {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1066(
-        __0,
-        __temp0,
-    )
+    __action1066(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1261<
->(
+fn __action1261(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> ast::Alias
-{
+) -> ast::Alias {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1067(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action1067(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1262<
->(
-    __0: (TextSize, ast::Identifier, TextSize),
-) -> ast::Alias
-{
+fn __action1262(__0: (TextSize, ast::Identifier, TextSize)) -> ast::Alias {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1068(
-        __0,
-        __temp0,
-    )
+    __action1068(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1263<
->(
-    __0: (TextSize, Vec<ast::Alias>, TextSize),
-) -> Vec<ast::Alias>
-{
+fn __action1263(__0: (TextSize, Vec<ast::Alias>, TextSize)) -> Vec<ast::Alias> {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action794(
-        __0,
-        __temp0,
-    )
+    __action794(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1264<
->(
+fn __action1264(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Alias>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Alias>
-{
+) -> Vec<ast::Alias> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action795(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action795(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1265<
->(
+fn __action1265(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Alias>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Alias>
-{
+) -> Vec<ast::Alias> {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action796(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action796(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1266<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Alias>
-{
+fn __action1266(__0: (TextSize, token::Tok, TextSize)) -> Vec<ast::Alias> {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action797(
-        __0,
-        __temp0,
-    )
+    __action797(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1267<
->(
+fn __action1267(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Alias>, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action798(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action798(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1268<
->(
+fn __action1268(
     __0: (TextSize, token::Tok, TextSize),
-    __1: (TextSize, (Option<ast::Int>, Option<ast::Identifier>), TextSize),
+    __1: (
+        TextSize,
+        (Option<ast::Int>, Option<ast::Identifier>),
+        TextSize,
+    ),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Vec<ast::Alias>, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action799(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action799(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1269<
->(
+fn __action1269(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Arguments>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action800(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action800(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1270<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+fn __action1270(__0: (TextSize, token::Tok, TextSize)) -> ast::Pattern {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action801(
-        __0,
-        __temp0,
-    )
+    __action801(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1271<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+fn __action1271(__0: (TextSize, token::Tok, TextSize)) -> ast::Pattern {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action802(
-        __0,
-        __temp0,
-    )
+    __action802(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1272<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+fn __action1272(__0: (TextSize, token::Tok, TextSize)) -> ast::Pattern {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action803(
-        __0,
-        __temp0,
-    )
+    __action803(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1273<
->(
-    __0: (TextSize, ast::Expr, TextSize),
-) -> ast::Pattern
-{
+fn __action1273(__0: (TextSize, ast::Expr, TextSize)) -> ast::Pattern {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action804(
-        __0,
-        __temp0,
-    )
+    __action804(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1274<
->(
-    __0: (TextSize, ast::Expr, TextSize),
-) -> ast::Pattern
-{
+fn __action1274(__0: (TextSize, ast::Expr, TextSize)) -> ast::Pattern {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action805(
-        __0,
-        __temp0,
-    )
+    __action805(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1275<
->(
-    __0: (TextSize, alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>, TextSize),
-) -> Result<ast::Pattern,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+fn __action1275(
+    __0: (
+        TextSize,
+        alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>,
+        TextSize,
+    ),
+) -> Result<ast::Pattern, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action806(
-        __0,
-        __temp0,
-    )
+    __action806(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1276<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+fn __action1276(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action807(
-        __0,
-        __temp0,
-    )
+    __action807(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1277<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+fn __action1277(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action808(
-        __0,
-        __temp0,
-    )
+    __action808(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1278<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+fn __action1278(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action809(
-        __0,
-        __temp0,
-    )
+    __action809(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1279<
->(
+fn __action1279(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action811(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action811(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1280<
->(
+fn __action1280(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action812(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action812(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1281<
->(
+fn __action1281(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action813(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action813(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1282<
->(
+fn __action1282(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action814(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action814(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1283<
->(
+fn __action1283(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action815(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action815(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1284<
->(
+fn __action1284(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -53577,332 +46145,195 @@ fn __action1284<
     __4: (TextSize, ast::Identifier, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action816(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __temp0,
-    )
+    __action816(__0, __1, __2, __3, __4, __5, __6, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1285<
->(
+fn __action1285(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Identifier, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action817(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-    )
+    __action817(__0, __1, __2, __3, __4, __5, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1286<
->(
-    __0: (TextSize, ast::Identifier, TextSize),
-) -> ast::Expr
-{
+fn __action1286(__0: (TextSize, ast::Identifier, TextSize)) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action819(
-        __0,
-        __temp0,
-    )
+    __action819(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1287<
->(
+fn __action1287(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action820(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action820(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1288<
->(
+fn __action1288(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action821(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action821(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1289<
->(
+fn __action1289(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action826(
-        __0,
-        __temp0,
-        __1,
-        __2,
-    )
+    __action826(__0, __temp0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1290<
->(
+fn __action1290(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Identifier>, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action827(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action827(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1291<
->(
+fn __action1291(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action828(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action828(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1292<
->(
+fn __action1292(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action829(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action829(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1293<
->(
-    __0: (TextSize, Vec<ast::Pattern>, TextSize),
-) -> ast::Pattern
-{
+fn __action1293(__0: (TextSize, Vec<ast::Pattern>, TextSize)) -> ast::Pattern {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action830(
-        __0,
-        __temp0,
-    )
+    __action830(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1294<
->(
+fn __action1294(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action831(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action831(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1295<
->(
+fn __action1295(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action832(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action832(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1296<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1296(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action948(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __temp0,
-    )
+    __action948(__0, __1, __2, __3, __4, __5, __6, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1297<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1297(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action949(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-    )
+    __action949(__0, __1, __2, __3, __4, __5, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1298<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1298(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
@@ -53910,959 +46341,614 @@ fn __action1298<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __7.2;
     let __end0 = __7.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action950(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-        __temp0,
-    )
+    __action950(__0, __1, __2, __3, __4, __5, __6, __7, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1299<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1299(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action951(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __temp0,
-    )
+    __action951(__0, __1, __2, __3, __4, __5, __6, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1300<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1300(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action952(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action952(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1301<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1301(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action953(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action953(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1302<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1302(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action954(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-    )
+    __action954(__0, __1, __2, __3, __4, __5, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1303<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1303(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action955(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action955(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1304<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1304(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action956(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action956(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1305<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1305(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action957(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-    )
+    __action957(__0, __1, __2, __3, __4, __5, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1306<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1306(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action958(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action958(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1307<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1307(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action959(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __temp0,
-    )
+    __action959(__0, __1, __2, __3, __4, __5, __6, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1308<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1308(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action960(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-    )
+    __action960(__0, __1, __2, __3, __4, __5, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1309<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1309(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action961(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action961(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1310<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1310(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action962(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action962(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1311<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1311(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action963(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action963(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1312<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1312(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action964(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1313<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action964(__0, __1, __2, __3, __temp0)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1313(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action965(
-        __0,
-        __temp0,
-    )
+    __action965(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1314<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1314(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action835(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action835(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1315<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1315(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action836(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action836(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1316<
->(
+fn __action1316(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action924(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action924(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1317<
->(
+fn __action1317(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action925(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action925(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1318<
->(
+fn __action1318(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action926(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-    )
+    __action926(__0, __1, __2, __3, __4, __5, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1319<
->(
+fn __action1319(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action927(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action927(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1320<
->(
+fn __action1320(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action928(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action928(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1321<
->(
+fn __action1321(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action929(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action929(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1322<
->(
+fn __action1322(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action930(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action930(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1323<
->(
+fn __action1323(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action931(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action931(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1324<
->(
+fn __action1324(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action932(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action932(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1325<
->(
+fn __action1325(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action933(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action933(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1326<
->(
+fn __action1326(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action934(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action934(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1327<
->(
+fn __action1327(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action935(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action935(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1328<
->(
+fn __action1328(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action936(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action936(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1329<
->(
+fn __action1329(
     __0: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action937(
-        __0,
-        __temp0,
-    )
+    __action937(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1330<
->(
+fn __action1330(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action938(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action938(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1331<
->(
+fn __action1331(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action939(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action939(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1332<
->(
+fn __action1332(
     __0: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Arguments
-{
+) -> ast::Arguments {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action839(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action839(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1333<
->(
-    __0: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> ast::Arguments
-{
+fn __action1333(__0: (TextSize, Option<Box<ast::Arg>>, TextSize)) -> ast::Arguments {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action840(
-        __0,
-        __temp0,
-    )
+    __action840(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1334<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1334(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1008(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __temp0,
-    )
+    __action1008(__0, __1, __2, __3, __4, __5, __6, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1335<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1335(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1009(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-    )
+    __action1009(__0, __1, __2, __3, __4, __5, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1336<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1336(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
@@ -54870,1752 +46956,1038 @@ fn __action1336<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __7.2;
     let __end0 = __7.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1010(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-        __temp0,
-    )
+    __action1010(__0, __1, __2, __3, __4, __5, __6, __7, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1337<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1337(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1011(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __temp0,
-    )
+    __action1011(__0, __1, __2, __3, __4, __5, __6, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1338<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1338(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1012(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action1012(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1339<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1339(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1013(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action1013(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1340<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1340(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1014(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-    )
+    __action1014(__0, __1, __2, __3, __4, __5, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1341<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1341(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1015(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action1015(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1342<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1342(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1016(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action1016(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1343<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1343(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1017(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-    )
+    __action1017(__0, __1, __2, __3, __4, __5, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1344<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1344(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1018(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action1018(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1345<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1345(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1019(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __temp0,
-    )
+    __action1019(__0, __1, __2, __3, __4, __5, __6, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1346<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1346(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1020(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-    )
+    __action1020(__0, __1, __2, __3, __4, __5, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1347<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1347(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1021(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action1021(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1348<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1348(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1022(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action1022(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1349<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1349(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1023(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action1023(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1350<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1350(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1024(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1351<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1024(__0, __1, __2, __3, __temp0)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1351(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1025(
-        __0,
-        __temp0,
-    )
+    __action1025(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1352<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1352(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action843(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action843(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1353<
->(
-    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+fn __action1353(
+    __0: (
+        TextSize,
+        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
+        TextSize,
+    ),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action844(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action844(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1354<
->(
+fn __action1354(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action984(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action984(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1355<
->(
+fn __action1355(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action985(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action985(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1356<
->(
+fn __action1356(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action986(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-    )
+    __action986(__0, __1, __2, __3, __4, __5, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1357<
->(
+fn __action1357(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action987(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action987(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1358<
->(
+fn __action1358(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action988(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action988(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1359<
->(
+fn __action1359(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action989(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action989(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1360<
->(
+fn __action1360(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action990(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action990(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1361<
->(
+fn __action1361(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action991(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action991(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1362<
->(
+fn __action1362(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action992(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action992(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1363<
->(
+fn __action1363(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action993(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action993(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1364<
->(
+fn __action1364(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action994(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action994(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1365<
->(
+fn __action1365(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action995(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action995(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1366<
->(
+fn __action1366(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action996(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action996(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1367<
->(
+fn __action1367(
     __0: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action997(
-        __0,
-        __temp0,
-    )
+    __action997(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1368<
->(
+fn __action1368(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action998(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action998(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1369<
->(
+fn __action1369(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action999(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action999(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1370<
->(
+fn __action1370(
     __0: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Arguments
-{
+) -> ast::Arguments {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action847(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action847(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1371<
->(
-    __0: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> ast::Arguments
-{
+fn __action1371(__0: (TextSize, Option<Box<ast::Arg>>, TextSize)) -> ast::Arguments {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action848(
-        __0,
-        __temp0,
-    )
+    __action848(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1372<
->(
+fn __action1372(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Arguments>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action861(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action861(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1373<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> ast::Stmt
-{
+fn __action1373(__0: (TextSize, token::Tok, TextSize)) -> ast::Stmt {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action862(
-        __0,
-        __temp0,
-    )
+    __action862(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1374<
->(
+fn __action1374(
     __0: (TextSize, ast::Pattern, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action863(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action863(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1375<
->(
+fn __action1375(
     __0: (TextSize, Vec<ast::Pattern>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action864(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action864(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1376<
->(
-    __0: (TextSize, Vec<ast::Pattern>, TextSize),
-) -> ast::Pattern
-{
+fn __action1376(__0: (TextSize, Vec<ast::Pattern>, TextSize)) -> ast::Pattern {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action865(
-        __0,
-        __temp0,
-    )
+    __action865(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1377<
->(
+fn __action1377(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action866(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action866(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1378<
->(
+fn __action1378(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action867(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action867(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1379<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> ast::Stmt
-{
+fn __action1379(__0: (TextSize, token::Tok, TextSize)) -> ast::Stmt {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action868(
-        __0,
-        __temp0,
-    )
+    __action868(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1380<
->(
+fn __action1380(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1093(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action1093(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1381<
->(
+fn __action1381(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1094(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action1094(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1382<
->(
+fn __action1382(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Pattern, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action870(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action870(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1383<
->(
+fn __action1383(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action871(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action871(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1384<
->(
+fn __action1384(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Pattern, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action872(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action872(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1385<
->(
+fn __action1385(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     __2: (TextSize, ast::Pattern, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action873(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action873(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1386<
->(
+fn __action1386(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     __2: (TextSize, ast::Pattern, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action874(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action874(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1387<
->(
+fn __action1387(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Pattern>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action875(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action875(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1388<
->(
+fn __action1388(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action876(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action876(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1389<
->(
+fn __action1389(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action877(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action877(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1390<
->(
+fn __action1390(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Expr, TextSize),
     __5: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
-) -> ast::Comprehension
-{
+) -> ast::Comprehension {
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action878(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __temp0,
-    )
+    __action878(__0, __1, __2, __3, __4, __5, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1391<
->(
+fn __action1391(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
-) -> ast::Comprehension
-{
+) -> ast::Comprehension {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action879(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action879(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1392<
->(
+fn __action1392(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action881(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action881(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1393<
->(
+fn __action1393(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Identifier, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action882(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action882(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1394<
->(
+fn __action1394(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Arg
-{
+) -> ast::Arg {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1058(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action1058(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1395<
->(
-    __0: (TextSize, ast::Identifier, TextSize),
-) -> ast::Arg
-{
+fn __action1395(__0: (TextSize, ast::Identifier, TextSize)) -> ast::Arg {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1059(
-        __0,
-        __temp0,
-    )
+    __action1059(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1396<
->(
-    __0: (TextSize, ast::Identifier, TextSize),
-) -> ast::Arg
-{
+fn __action1396(__0: (TextSize, ast::Identifier, TextSize)) -> ast::Arg {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action884(
-        __0,
-        __temp0,
-    )
+    __action884(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1397<
->(
+fn __action1397(
     __0: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __3: (TextSize, core::option::Option<Option<ast::Expr>>, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action885(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action885(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1398<
->(
-    __0: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action1398(__0: (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action886(
-        __0,
-        __temp0,
-    )
+    __action886(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1399<
->(
+fn __action1399(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action887(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action887(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1400<
->(
+fn __action1400(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action888(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action888(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1401<
->(
-    __0: (TextSize, Vec<ast::Expr>, TextSize),
-) -> ast::Expr
-{
+fn __action1401(__0: (TextSize, Vec<ast::Expr>, TextSize)) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action889(
-        __0,
-        __temp0,
-    )
+    __action889(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1402<
->(
+fn __action1402(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action890(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action890(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1403<
->(
+fn __action1403(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action891(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action891(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1404<
->(
+fn __action1404(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action892(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action892(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1405<
->(
+fn __action1405(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action893(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action893(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1406<
->(
+fn __action1406(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Suite, TextSize),
-) -> ast::Mod
-{
+) -> ast::Mod {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action894(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action894(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1407<
->(
+fn __action1407(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Suite, TextSize),
-) -> ast::Mod
-{
+) -> ast::Mod {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action895(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action895(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1408<
->(
+fn __action1408(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Mod
-{
+) -> ast::Mod {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1062(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action1062(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1409<
->(
+fn __action1409(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<token::Tok>, TextSize),
-) -> ast::Mod
-{
+) -> ast::Mod {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1063(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action1063(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1410<
->(
+fn __action1410(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -56626,33 +47998,16 @@ fn __action1410<
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, token::Tok, TextSize),
     __9: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __9.2;
     let __end0 = __9.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1084(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-        __9,
-        __temp0,
-    )
+    __action1084(__0, __1, __2, __3, __4, __5, __6, __7, __8, __9, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1411<
->(
+fn __action1411(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -56660,30 +48015,16 @@ fn __action1411<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1085(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __temp0,
-    )
+    __action1085(__0, __1, __2, __3, __4, __5, __6, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1412<
->(
+fn __action1412(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -56691,55 +48032,30 @@ fn __action1412<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1086(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __temp0,
-    )
+    __action1086(__0, __1, __2, __3, __4, __5, __6, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1413<
->(
+fn __action1413(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ExceptHandler>, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1087(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action1087(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1414<
->(
+fn __action1414(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -56750,33 +48066,16 @@ fn __action1414<
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, token::Tok, TextSize),
     __9: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __9.2;
     let __end0 = __9.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1088(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-        __9,
-        __temp0,
-    )
+    __action1088(__0, __1, __2, __3, __4, __5, __6, __7, __8, __9, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1415<
->(
+fn __action1415(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -56784,30 +48083,16 @@ fn __action1415<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1089(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __temp0,
-    )
+    __action1089(__0, __1, __2, __3, __4, __5, __6, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1416<
->(
+fn __action1416(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -56815,485 +48100,268 @@ fn __action1416<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1090(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __temp0,
-    )
+    __action1090(__0, __1, __2, __3, __4, __5, __6, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1417<
->(
+fn __action1417(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ExceptHandler>, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1091(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action1091(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1418<
->(
+fn __action1418(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::ArgWithDefault
-{
+) -> ast::ArgWithDefault {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1055(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action1055(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1419<
->(
-    __0: (TextSize, ast::Identifier, TextSize),
-) -> ast::ArgWithDefault
-{
+fn __action1419(__0: (TextSize, ast::Identifier, TextSize)) -> ast::ArgWithDefault {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1056(
-        __0,
-        __temp0,
-    )
+    __action1056(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1420<
->(
-    __0: (TextSize, ast::Identifier, TextSize),
-) -> ast::ArgWithDefault
-{
+fn __action1420(__0: (TextSize, ast::Identifier, TextSize)) -> ast::ArgWithDefault {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action901(
-        __0,
-        __temp0,
-    )
+    __action901(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1421<
->(
-    __0: (TextSize, ast::Expr, TextSize),
-) -> ast::Pattern
-{
+fn __action1421(__0: (TextSize, ast::Expr, TextSize)) -> ast::Pattern {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action902(
-        __0,
-        __temp0,
-    )
+    __action902(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1422<
->(
-    __0: (TextSize, ast::Expr, TextSize),
-) -> ast::WithItem
-{
+fn __action1422(__0: (TextSize, ast::Expr, TextSize)) -> ast::WithItem {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action904(
-        __0,
-        __temp0,
-    )
+    __action904(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1423<
->(
+fn __action1423(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::WithItem
-{
+) -> ast::WithItem {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action905(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action905(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1424<
->(
+fn __action1424(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::WithItem
-{
+) -> ast::WithItem {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action906(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action906(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1425<
->(
-    __0: (TextSize, ast::Expr, TextSize),
-) -> ast::WithItem
-{
+fn __action1425(__0: (TextSize, ast::Expr, TextSize)) -> ast::WithItem {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action907(
-        __0,
-        __temp0,
-    )
+    __action907(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1426<
->(
+fn __action1426(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::WithItem
-{
+) -> ast::WithItem {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action908(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action908(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1427<
->(
-    __0: (TextSize, Vec<ast::Expr>, TextSize),
-) -> Vec<ast::WithItem>
-{
+fn __action1427(__0: (TextSize, Vec<ast::Expr>, TextSize)) -> Vec<ast::WithItem> {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action909(
-        __0,
-        __temp0,
-    )
+    __action909(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1428<
->(
+fn __action1428(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action912(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action912(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1429<
->(
+fn __action1429(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action913(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action913(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1430<
->(
+fn __action1430(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Expr>, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action914(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action914(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1431<
->(
+fn __action1431(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action372(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action915(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action915(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1432<
->(
+fn __action1432(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action1427(
-        __0,
-    );
+    let __temp0 = __action1427(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action289(
-        __temp0,
-        __1,
-    )
+    __action289(__temp0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1433<
->(
+fn __action1433(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action1427(
-        __1,
-    );
+    let __temp0 = __action1427(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action625(
-        __0,
-        __temp0,
-        __2,
-        __3,
-    )
+    __action625(__0, __temp0, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1434<
->(
+fn __action1434(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action1427(
-        __1,
-    );
+    let __temp0 = __action1427(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action626(
-        __0,
-        __temp0,
-        __2,
-    )
+    __action626(__0, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1435<
->(
+fn __action1435(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> core::option::Option<Vec<ast::WithItem>>
-{
+) -> core::option::Option<Vec<ast::WithItem>> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action1432(
-        __0,
-        __1,
-    );
+    let __temp0 = __action1432(__0, __1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action287(
-        __temp0,
-    )
+    __action287(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1436<
->(
+fn __action1436(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::WithItem, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1435(
-        __1,
-        __2,
-    );
+    let __temp0 = __action1435(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1041(
-        __0,
-        __temp0,
-        __3,
-        __4,
-        __5,
-    )
+    __action1041(__0, __temp0, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1437<
->(
+fn __action1437(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::WithItem, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action288(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action288(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1041(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-    )
+    __action1041(__0, __temp0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1438<
->(
+fn __action1438(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -57301,889 +48369,601 @@ fn __action1438<
     __4: (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1435(
-        __1,
-        __2,
-    );
+    let __temp0 = __action1435(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1042(
-        __0,
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action1042(__0, __temp0, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1439<
->(
+fn __action1439(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::WithItem, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action288(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action288(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1042(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action1042(__0, __temp0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1440<
->(
+fn __action1440(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::WithItem, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1435(
-        __1,
-        __2,
-    );
+    let __temp0 = __action1435(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1043(
-        __0,
-        __temp0,
-        __3,
-        __4,
-    )
+    __action1043(__0, __temp0, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1441<
->(
+fn __action1441(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::WithItem, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action288(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action288(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1043(
-        __0,
-        __temp0,
-        __1,
-        __2,
-    )
+    __action1043(__0, __temp0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1442<
->(
+fn __action1442(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::WithItem, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1435(
-        __1,
-        __2,
-    );
+    let __temp0 = __action1435(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1044(
-        __0,
-        __temp0,
-        __3,
-        __4,
-        __5,
-    )
+    __action1044(__0, __temp0, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1443<
->(
+fn __action1443(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::WithItem, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem>
-{
+) -> Vec<ast::WithItem> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action288(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action288(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1044(
-        __0,
-        __temp0,
-        __1,
-        __2,
-        __3,
-    )
+    __action1044(__0, __temp0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1444<
->(
+fn __action1444(
     __0: (TextSize, (String, StringKind, bool), TextSize),
-) -> alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>
-{
+) -> alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action1150(
-        __0,
-    );
+    let __temp0 = __action1150(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action314(
-        __temp0,
-    )
+    __action314(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1445<
->(
-    __0: (TextSize, alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>, TextSize),
+fn __action1445(
+    __0: (
+        TextSize,
+        alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>,
+        TextSize,
+    ),
     __1: (TextSize, (String, StringKind, bool), TextSize),
-) -> alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>
-{
+) -> alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action1150(
-        __1,
-    );
+    let __temp0 = __action1150(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action315(
-        __0,
-        __temp0,
-    )
+    __action315(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1446<
->(
+fn __action1446(
     __0: (TextSize, ast::CmpOp, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<(ast::CmpOp, ast::Expr)>
-{
+) -> alloc::vec::Vec<(ast::CmpOp, ast::Expr)> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action473(
-        __0,
-        __1,
-    );
+    let __temp0 = __action473(__0, __1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action471(
-        __temp0,
-    )
+    __action471(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1447<
->(
+fn __action1447(
     __0: (TextSize, alloc::vec::Vec<(ast::CmpOp, ast::Expr)>, TextSize),
     __1: (TextSize, ast::CmpOp, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<(ast::CmpOp, ast::Expr)>
-{
+) -> alloc::vec::Vec<(ast::CmpOp, ast::Expr)> {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action473(
-        __1,
-        __2,
-    );
+    let __temp0 = __action473(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action472(
-        __0,
-        __temp0,
-    )
+    __action472(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1448<
->(
-    __0: (TextSize, ast::Expr, TextSize),
-) -> core::option::Option<ast::Expr>
-{
+fn __action1448(__0: (TextSize, ast::Expr, TextSize)) -> core::option::Option<ast::Expr> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action327(
-        __0,
-    );
+    let __temp0 = __action327(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action325(
-        __temp0,
-    )
+    __action325(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1449<
->(
+fn __action1449(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Pattern, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Suite, TextSize),
-) -> ast::MatchCase
-{
+) -> ast::MatchCase {
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action1448(
-        __2,
-    );
+    let __temp0 = __action1448(__2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action818(
-        __0,
-        __1,
-        __temp0,
-        __3,
-        __4,
-    )
+    __action818(__0, __1, __temp0, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1450<
->(
+fn __action1450(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Pattern, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-) -> ast::MatchCase
-{
+) -> ast::MatchCase {
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action326(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action326(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action818(
-        __0,
-        __1,
-        __temp0,
-        __2,
-        __3,
-    )
+    __action818(__0, __1, __temp0, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1451<
->(
-    __0: (TextSize, ast::Arguments, TextSize),
-) -> core::option::Option<ast::Arguments>
-{
+fn __action1451(__0: (TextSize, ast::Arguments, TextSize)) -> core::option::Option<ast::Arguments> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action265(
-        __0,
-    );
+    let __temp0 = __action265(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action263(
-        __temp0,
-    )
+    __action263(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1452<
->(
+fn __action1452(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arguments, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action1451(
-        __1,
-    );
+    let __temp0 = __action1451(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1372(
-        __0,
-        __temp0,
-        __2,
-    )
+    __action1372(__0, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1453<
->(
+fn __action1453(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action264(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action264(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1372(
-        __0,
-        __temp0,
-        __1,
-    )
+    __action1372(__0, __temp0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1454<
->(
-    __0: (TextSize, ast::Expr, TextSize),
-) -> ast::Stmt
-{
+fn __action1454(__0: (TextSize, ast::Expr, TextSize)) -> ast::Stmt {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action362(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action362(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1241(
-        __0,
-        __temp0,
-    )
+    __action1241(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1455<
->(
+fn __action1455(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action363(
-        __1,
-    );
+    let __temp0 = __action363(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1241(
-        __0,
-        __temp0,
-    )
+    __action1241(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1456<
->(
+fn __action1456(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action357(
-        __3,
-    );
+    let __temp0 = __action357(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1243(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action1243(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1457<
->(
+fn __action1457(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action358(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action358(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1243(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action1243(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1458<
->(
-    __0: (TextSize, (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr), TextSize),
-) -> Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
-{
+fn __action1458(
+    __0: (
+        TextSize,
+        (
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        ),
+        TextSize,
+    ),
+) -> Vec<(
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+)> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action421(
-        __0,
-    );
+    let __temp0 = __action421(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1105(
-        __temp0,
-    )
+    __action1105(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1459<
->(
+fn __action1459(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
-{
+) -> Vec<(
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+)> {
     let __start0 = *__lookbehind;
     let __end0 = *__lookahead;
-    let __temp0 = __action422(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1105(
-        __temp0,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1460<
->(
-    __0: (TextSize, alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
-    __1: (TextSize, (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr), TextSize),
-) -> Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
-{
+    let __temp0 = __action422(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1105(__temp0)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1460(
+    __0: (
+        TextSize,
+        alloc::vec::Vec<(
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        )>,
+        TextSize,
+    ),
+    __1: (
+        TextSize,
+        (
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        ),
+        TextSize,
+    ),
+) -> Vec<(
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+)> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action421(
-        __1,
-    );
+    let __temp0 = __action421(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1106(
-        __0,
-        __temp0,
-    )
+    __action1106(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1461<
->(
-    __0: (TextSize, alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
-) -> Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
-{
+fn __action1461(
+    __0: (
+        TextSize,
+        alloc::vec::Vec<(
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        )>,
+        TextSize,
+    ),
+) -> Vec<(
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+)> {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action422(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action422(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1106(
-        __0,
-        __temp0,
-    )
+    __action1106(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1462<
->(
-    __0: (TextSize, (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr), TextSize),
-) -> Result<ArgumentList,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+fn __action1462(
+    __0: (
+        TextSize,
+        (
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        ),
+        TextSize,
+    ),
+) -> Result<ArgumentList, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action1458(
-        __0,
-    );
+    let __temp0 = __action1458(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action216(
-        __temp0,
-    )
+    __action216(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1463<
->(
+fn __action1463(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> Result<ArgumentList,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ArgumentList, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = *__lookbehind;
     let __end0 = *__lookahead;
-    let __temp0 = __action1459(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action216(
-        __temp0,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1464<
->(
-    __0: (TextSize, alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
-    __1: (TextSize, (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr), TextSize),
-) -> Result<ArgumentList,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+    let __temp0 = __action1459(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action216(__temp0)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1464(
+    __0: (
+        TextSize,
+        alloc::vec::Vec<(
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        )>,
+        TextSize,
+    ),
+    __1: (
+        TextSize,
+        (
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        ),
+        TextSize,
+    ),
+) -> Result<ArgumentList, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action1460(
-        __0,
-        __1,
-    );
+    let __temp0 = __action1460(__0, __1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action216(
-        __temp0,
-    )
+    __action216(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1465<
->(
-    __0: (TextSize, alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
-) -> Result<ArgumentList,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+fn __action1465(
+    __0: (
+        TextSize,
+        alloc::vec::Vec<(
+            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+            ast::Expr,
+        )>,
+        TextSize,
+    ),
+) -> Result<ArgumentList, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action1461(
-        __0,
-    );
+    let __temp0 = __action1461(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action216(
-        __temp0,
-    )
+    __action216(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1466<
->(
-    __0: (TextSize, ast::Pattern, TextSize),
-) -> Vec<ast::Pattern>
-{
+fn __action1466(__0: (TextSize, ast::Pattern, TextSize)) -> Vec<ast::Pattern> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action383(
-        __0,
-    );
+    let __temp0 = __action383(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1128(
-        __temp0,
-    )
+    __action1128(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1467<
->(
-    __lookbehind: &TextSize,
-    __lookahead: &TextSize,
-) -> Vec<ast::Pattern>
-{
+fn __action1467(__lookbehind: &TextSize, __lookahead: &TextSize) -> Vec<ast::Pattern> {
     let __start0 = *__lookbehind;
     let __end0 = *__lookahead;
-    let __temp0 = __action384(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action384(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1128(
-        __temp0,
-    )
+    __action1128(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1468<
->(
+fn __action1468(
     __0: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     __1: (TextSize, ast::Pattern, TextSize),
-) -> Vec<ast::Pattern>
-{
+) -> Vec<ast::Pattern> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action383(
-        __1,
-    );
+    let __temp0 = __action383(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1129(
-        __0,
-        __temp0,
-    )
+    __action1129(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1469<
->(
-    __0: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
-) -> Vec<ast::Pattern>
-{
+fn __action1469(__0: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize)) -> Vec<ast::Pattern> {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action384(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action384(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1129(
-        __0,
-        __temp0,
-    )
+    __action1129(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1470<
->(
+fn __action1470(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Pattern, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action1466(
-        __1,
-    );
+    let __temp0 = __action1466(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1387(
-        __0,
-        __temp0,
-        __2,
-    )
+    __action1387(__0, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1471<
->(
+fn __action1471(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action1467(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action1467(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1387(
-        __0,
-        __temp0,
-        __1,
-    )
+    __action1387(__0, __temp0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1472<
->(
+fn __action1472(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     __2: (TextSize, ast::Pattern, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1468(
-        __1,
-        __2,
-    );
+    let __temp0 = __action1468(__1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1387(
-        __0,
-        __temp0,
-        __3,
-    )
+    __action1387(__0, __temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1473<
->(
+fn __action1473(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern
-{
+) -> ast::Pattern {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action1469(
-        __1,
-    );
+    let __temp0 = __action1469(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1387(
-        __0,
-        __temp0,
-        __2,
-    )
+    __action1387(__0, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1474<
->(
+fn __action1474(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, Vec<ast::Comprehension>, TextSize),
-) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
-{
+) -> (
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+) {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action225(
-        __1,
-    );
+    let __temp0 = __action225(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1250(
-        __0,
-        __temp0,
-    )
+    __action1250(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1475<
->(
+fn __action1475(
     __0: (TextSize, ast::Expr, TextSize),
-) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
-{
+) -> (
+    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
+    ast::Expr,
+) {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action226(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action226(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1250(
-        __0,
-        __temp0,
-    )
+    __action1250(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1476<
->(
+fn __action1476(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Expr, TextSize),
-) -> ast::Comprehension
-{
+) -> ast::Comprehension {
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action228(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action228(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1390(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action1390(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1477<
->(
+fn __action1477(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Expr, TextSize),
     __5: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
-) -> ast::Comprehension
-{
+) -> ast::Comprehension {
     let __start0 = __5.0;
     let __end0 = __5.2;
-    let __temp0 = __action229(
-        __5,
-    );
+    let __temp0 = __action229(__5);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1390(
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __temp0,
-    )
+    __action1390(__0, __1, __2, __3, __4, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1478<
->(
+fn __action1478(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
-) -> ast::Comprehension
-{
+) -> ast::Comprehension {
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action228(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action228(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1391(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action1391(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1479<
->(
+fn __action1479(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
-) -> ast::Comprehension
-{
+) -> ast::Comprehension {
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action229(
-        __4,
-    );
+    let __temp0 = __action229(__4);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1391(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-    )
+    __action1391(__0, __1, __2, __3, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1480<
->(
+fn __action1480(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Identifier, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -58191,30 +48971,16 @@ fn __action1480<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action273(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action740(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1481<
->(
+    let __temp0 = __action273(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action740(__temp0, __0, __1, __2, __3, __4, __5, __6)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1481(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
@@ -58223,79 +48989,45 @@ fn __action1481<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action274(
-        __0,
-    );
+    let __temp0 = __action274(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action740(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action740(__temp0, __1, __2, __3, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1482<
->(
+fn __action1482(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Identifier, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action273(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action273(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action741(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-    )
+    __action741(__temp0, __0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1483<
->(
+fn __action1483(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action274(
-        __0,
-    );
+    let __temp0 = __action274(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action741(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action741(__temp0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1484<
->(
+fn __action1484(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
@@ -58304,31 +49036,16 @@ fn __action1484<
     __5: (TextSize, ast::Expr, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action273(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1046(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1485<
->(
+    let __temp0 = __action273(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1046(__temp0, __0, __1, __2, __3, __4, __5, __6, __7)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1485(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -58338,59 +49055,32 @@ fn __action1485<
     __6: (TextSize, ast::Expr, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action274(
-        __0,
-    );
+    let __temp0 = __action274(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1046(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-    )
+    __action1046(__temp0, __1, __2, __3, __4, __5, __6, __7, __8)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1486<
->(
+fn __action1486(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, ast::Arguments, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action273(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action273(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1047(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action1047(__temp0, __0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1487<
->(
+fn __action1487(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -58398,28 +49088,16 @@ fn __action1487<
     __4: (TextSize, ast::Arguments, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action274(
-        __0,
-    );
+    let __temp0 = __action274(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1047(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action1047(__temp0, __1, __2, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1488<
->(
+fn __action1488(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Identifier, TextSize),
     __2: (TextSize, ast::Arguments, TextSize),
@@ -58427,30 +49105,16 @@ fn __action1488<
     __4: (TextSize, ast::Expr, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action273(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1048(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1489<
->(
+    let __temp0 = __action273(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1048(__temp0, __0, __1, __2, __3, __4, __5, __6)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1489(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
@@ -58459,495 +49123,291 @@ fn __action1489<
     __5: (TextSize, ast::Expr, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action274(
-        __0,
-    );
+    let __temp0 = __action274(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1048(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action1048(__temp0, __1, __2, __3, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1490<
->(
+fn __action1490(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Identifier, TextSize),
     __2: (TextSize, ast::Arguments, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action273(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action273(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1049(
-        __temp0,
-        __0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action1049(__temp0, __0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1491<
->(
+fn __action1491(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, ast::Arguments, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action274(
-        __0,
-    );
+    let __temp0 = __action274(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1049(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action1049(__temp0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1492<
->(
+fn __action1492(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<(Option<Box<ast::Expr>>, ast::Expr)>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action523(
-        __1,
-    );
+    let __temp0 = __action523(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1178(
-        __0,
-        __temp0,
-        __2,
-    )
+    __action1178(__0, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1493<
->(
+fn __action1493(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action524(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action524(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1178(
-        __0,
-        __temp0,
-        __1,
-    )
+    __action1178(__0, __temp0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1494<
->(
+fn __action1494(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<(Option<Box<ast::Expr>>, ast::Expr)>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action523(
-        __1,
-    );
+    let __temp0 = __action523(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1201(
-        __0,
-        __temp0,
-        __2,
-    )
+    __action1201(__0, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1495<
->(
+fn __action1495(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action524(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action524(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1201(
-        __0,
-        __temp0,
-        __1,
-    )
+    __action1201(__0, __temp0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1496<
->(
+fn __action1496(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
-) -> Option<Box<ast::Arg>>
-{
+) -> Option<Box<ast::Arg>> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action457(
-        __1,
-    );
+    let __temp0 = __action457(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action395(
-        __0,
-        __temp0,
-    )
+    __action395(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1497<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> Option<Box<ast::Arg>>
-{
+fn __action1497(__0: (TextSize, token::Tok, TextSize)) -> Option<Box<ast::Arg>> {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action458(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action458(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action395(
-        __0,
-        __temp0,
-    )
+    __action395(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1498<
->(
+fn __action1498(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> Vec<ast::Alias>
-{
+) -> Vec<ast::Alias> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action1259(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action1259(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action349(
-        __temp0,
-    )
+    __action349(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1499<
->(
-    __0: (TextSize, ast::Identifier, TextSize),
-) -> Vec<ast::Alias>
-{
+fn __action1499(__0: (TextSize, ast::Identifier, TextSize)) -> Vec<ast::Alias> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action1260(
-        __0,
-    );
+    let __temp0 = __action1260(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action349(
-        __temp0,
-    )
+    __action349(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1500<
->(
+fn __action1500(
     __0: (TextSize, Vec<ast::Alias>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Identifier, TextSize),
-) -> Vec<ast::Alias>
-{
+) -> Vec<ast::Alias> {
     let __start0 = __2.0;
     let __end0 = __4.2;
-    let __temp0 = __action1259(
-        __2,
-        __3,
-        __4,
-    );
+    let __temp0 = __action1259(__2, __3, __4);
     let __temp0 = (__start0, __temp0, __end0);
-    __action350(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action350(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1501<
->(
+fn __action1501(
     __0: (TextSize, Vec<ast::Alias>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> Vec<ast::Alias>
-{
+) -> Vec<ast::Alias> {
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action1260(
-        __2,
-    );
+    let __temp0 = __action1260(__2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action350(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action350(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1502<
->(
+fn __action1502(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> Vec<ast::Alias>
-{
+) -> Vec<ast::Alias> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action1261(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action1261(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action342(
-        __temp0,
-    )
+    __action342(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1503<
->(
-    __0: (TextSize, ast::Identifier, TextSize),
-) -> Vec<ast::Alias>
-{
+fn __action1503(__0: (TextSize, ast::Identifier, TextSize)) -> Vec<ast::Alias> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action1262(
-        __0,
-    );
+    let __temp0 = __action1262(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action342(
-        __temp0,
-    )
+    __action342(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1504<
->(
+fn __action1504(
     __0: (TextSize, Vec<ast::Alias>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Identifier, TextSize),
-) -> Vec<ast::Alias>
-{
+) -> Vec<ast::Alias> {
     let __start0 = __2.0;
     let __end0 = __4.2;
-    let __temp0 = __action1261(
-        __2,
-        __3,
-        __4,
-    );
+    let __temp0 = __action1261(__2, __3, __4);
     let __temp0 = (__start0, __temp0, __end0);
-    __action343(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action343(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1505<
->(
+fn __action1505(
     __0: (TextSize, Vec<ast::Alias>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> Vec<ast::Alias>
-{
+) -> Vec<ast::Alias> {
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action1262(
-        __2,
-    );
+    let __temp0 = __action1262(__2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action343(
-        __0,
-        __1,
-        __temp0,
-    )
+    __action343(__0, __1, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1506<
->(
+fn __action1506(
     __0: (TextSize, ast::Identifier, TextSize),
-) -> (Option<ast::Int>, Option<ast::Identifier>)
-{
+) -> (Option<ast::Int>, Option<ast::Identifier>) {
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action347(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action347(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action59(
-        __temp0,
-        __0,
-    )
+    __action59(__temp0, __0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1507<
->(
+fn __action1507(
     __0: (TextSize, alloc::vec::Vec<ast::Int>, TextSize),
     __1: (TextSize, ast::Identifier, TextSize),
-) -> (Option<ast::Int>, Option<ast::Identifier>)
-{
+) -> (Option<ast::Int>, Option<ast::Identifier>) {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action348(
-        __0,
-    );
+    let __temp0 = __action348(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action59(
-        __temp0,
-        __1,
-    )
+    __action59(__temp0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1508<
->(
+fn __action1508(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action531(
-        __1,
-    );
+    let __temp0 = __action531(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1163(
-        __0,
-        __temp0,
-        __2,
-    )
+    __action1163(__0, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1509<
->(
+fn __action1509(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action532(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action532(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1163(
-        __0,
-        __temp0,
-        __1,
-    )
+    __action1163(__0, __temp0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1510<
->(
+fn __action1510(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action531(
-        __1,
-    );
+    let __temp0 = __action531(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1188(
-        __0,
-        __temp0,
-        __2,
-    )
+    __action1188(__0, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1511<
->(
+fn __action1511(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action532(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action532(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1188(
-        __0,
-        __temp0,
-        __1,
-    )
+    __action1188(__0, __temp0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1512<
->(
+fn __action1512(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -58955,28 +49415,16 @@ fn __action1512<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(
-        __0,
-    );
+    let __temp0 = __action400(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1296(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action1296(__temp0, __1, __2, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1513<
->(
+fn __action1513(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -58986,30 +49434,16 @@ fn __action1513<
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __8: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(
-        __0,
-        __1,
-        __2,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1296(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1514<
->(
+    let __temp0 = __action660(__0, __1, __2);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1296(__temp0, __3, __4, __5, __6, __7, __8)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1514(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59020,58 +49454,32 @@ fn __action1514<
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __9: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1296(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-        __9,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1515<
->(
+    let __temp0 = __action661(__0, __1, __2, __3);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1296(__temp0, __4, __5, __6, __7, __8, __9)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1515(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(
-        __0,
-    );
+    let __temp0 = __action400(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1297(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action1297(__temp0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1516<
->(
+fn __action1516(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59080,29 +49488,16 @@ fn __action1516<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action660(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1297(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action1297(__temp0, __3, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1517<
->(
+fn __action1517(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59112,30 +49507,16 @@ fn __action1517<
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __8: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1297(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1518<
->(
+    let __temp0 = __action661(__0, __1, __2, __3);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1297(__temp0, __4, __5, __6, __7, __8)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1518(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59144,29 +49525,16 @@ fn __action1518<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(
-        __0,
-    );
+    let __temp0 = __action400(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1298(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action1298(__temp0, __1, __2, __3, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1519<
->(
+fn __action1519(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59177,31 +49545,16 @@ fn __action1519<
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __9: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(
-        __0,
-        __1,
-        __2,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1298(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-        __9,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1520<
->(
+    let __temp0 = __action660(__0, __1, __2);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1298(__temp0, __3, __4, __5, __6, __7, __8, __9)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1520(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59213,32 +49566,16 @@ fn __action1520<
     __8: (TextSize, token::Tok, TextSize),
     __9: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __10: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1298(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-        __9,
-        __10,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1521<
->(
+    let __temp0 = __action661(__0, __1, __2, __3);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1298(__temp0, __4, __5, __6, __7, __8, __9, __10)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1521(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59246,28 +49583,16 @@ fn __action1521<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(
-        __0,
-    );
+    let __temp0 = __action400(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1299(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action1299(__temp0, __1, __2, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1522<
->(
+fn __action1522(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59277,30 +49602,16 @@ fn __action1522<
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __8: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(
-        __0,
-        __1,
-        __2,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1299(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1523<
->(
+    let __temp0 = __action660(__0, __1, __2);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1299(__temp0, __3, __4, __5, __6, __7, __8)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1523(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59311,56 +49622,31 @@ fn __action1523<
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __9: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1299(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-        __9,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1524<
->(
+    let __temp0 = __action661(__0, __1, __2, __3);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1299(__temp0, __4, __5, __6, __7, __8, __9)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1524(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(
-        __0,
-    );
+    let __temp0 = __action400(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1300(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action1300(__temp0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1525<
->(
+fn __action1525(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59368,28 +49654,16 @@ fn __action1525<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Arg, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action660(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1300(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action1300(__temp0, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1526<
->(
+fn __action1526(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59398,79 +49672,46 @@ fn __action1526<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Arg, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action661(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1300(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action1300(__temp0, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1527<
->(
+fn __action1527(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(
-        __0,
-    );
+    let __temp0 = __action400(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1301(
-        __temp0,
-        __1,
-        __2,
-        __3,
-    )
+    __action1301(__temp0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1528<
->(
+fn __action1528(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action660(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1301(
-        __temp0,
-        __3,
-        __4,
-        __5,
-    )
+    __action1301(__temp0, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1529<
->(
+fn __action1529(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59478,55 +49719,32 @@ fn __action1529<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action661(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1301(
-        __temp0,
-        __4,
-        __5,
-        __6,
-    )
+    __action1301(__temp0, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1530<
->(
+fn __action1530(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(
-        __0,
-    );
+    let __temp0 = __action400(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1302(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action1302(__temp0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1531<
->(
+fn __action1531(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59535,29 +49753,16 @@ fn __action1531<
     __5: (TextSize, ast::Arg, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action660(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1302(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action1302(__temp0, __3, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1532<
->(
+fn __action1532(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59567,55 +49772,31 @@ fn __action1532<
     __6: (TextSize, ast::Arg, TextSize),
     __7: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __8: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1302(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1533<
->(
+    let __temp0 = __action661(__0, __1, __2, __3);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1302(__temp0, __4, __5, __6, __7, __8)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1533(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(
-        __0,
-    );
+    let __temp0 = __action400(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1303(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action1303(__temp0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1534<
->(
+fn __action1534(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59623,28 +49804,16 @@ fn __action1534<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action660(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1303(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action1303(__temp0, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1535<
->(
+fn __action1535(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59653,123 +49822,73 @@ fn __action1535<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action661(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1303(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action1303(__temp0, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1536<
->(
+fn __action1536(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(
-        __0,
-    );
+    let __temp0 = __action400(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1304(
-        __temp0,
-        __1,
-    )
+    __action1304(__temp0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1537<
->(
+fn __action1537(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action660(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1304(
-        __temp0,
-        __3,
-    )
+    __action1304(__temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1538<
->(
+fn __action1538(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action661(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1304(
-        __temp0,
-        __4,
-    )
+    __action1304(__temp0, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1539<
->(
+fn __action1539(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(
-        __0,
-    );
+    let __temp0 = __action400(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1305(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action1305(__temp0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1540<
->(
+fn __action1540(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59778,29 +49897,16 @@ fn __action1540<
     __5: (TextSize, ast::Arg, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action660(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1305(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action1305(__temp0, __3, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1541<
->(
+fn __action1541(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59810,55 +49916,31 @@ fn __action1541<
     __6: (TextSize, ast::Arg, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1305(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1542<
->(
+    let __temp0 = __action661(__0, __1, __2, __3);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1305(__temp0, __4, __5, __6, __7, __8)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1542(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(
-        __0,
-    );
+    let __temp0 = __action400(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1306(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action1306(__temp0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1543<
->(
+fn __action1543(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59866,28 +49948,16 @@ fn __action1543<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action660(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1306(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action1306(__temp0, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1544<
->(
+fn __action1544(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59896,29 +49966,16 @@ fn __action1544<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action661(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1306(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action1306(__temp0, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1545<
->(
+fn __action1545(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59926,28 +49983,16 @@ fn __action1545<
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(
-        __0,
-    );
+    let __temp0 = __action400(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1307(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action1307(__temp0, __1, __2, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1546<
->(
+fn __action1546(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59957,30 +50002,16 @@ fn __action1546<
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(
-        __0,
-        __1,
-        __2,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1307(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1547<
->(
+    let __temp0 = __action660(__0, __1, __2);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1307(__temp0, __3, __4, __5, __6, __7, __8)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1547(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -59991,58 +50022,32 @@ fn __action1547<
     __7: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __8: (TextSize, token::Tok, TextSize),
     __9: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1307(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-        __9,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1548<
->(
+    let __temp0 = __action661(__0, __1, __2, __3);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1307(__temp0, __4, __5, __6, __7, __8, __9)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1548(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(
-        __0,
-    );
+    let __temp0 = __action400(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1308(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action1308(__temp0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1549<
->(
+fn __action1549(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -60051,29 +50056,16 @@ fn __action1549<
     __5: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action660(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1308(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action1308(__temp0, __3, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1550<
->(
+fn __action1550(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -60083,80 +50075,46 @@ fn __action1550<
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1308(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1551<
->(
+    let __temp0 = __action661(__0, __1, __2, __3);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1308(__temp0, __4, __5, __6, __7, __8)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1551(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(
-        __0,
-    );
+    let __temp0 = __action400(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1309(
-        __temp0,
-        __1,
-        __2,
-        __3,
-    )
+    __action1309(__temp0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1552<
->(
+fn __action1552(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Arg, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action660(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1309(
-        __temp0,
-        __3,
-        __4,
-        __5,
-    )
+    __action1309(__temp0, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1553<
->(
+fn __action1553(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -60164,126 +50122,75 @@ fn __action1553<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Arg, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action661(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1309(
-        __temp0,
-        __4,
-        __5,
-        __6,
-    )
+    __action1309(__temp0, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1554<
->(
+fn __action1554(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(
-        __0,
-    );
+    let __temp0 = __action400(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1310(
-        __temp0,
-        __1,
-        __2,
-    )
+    __action1310(__temp0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1555<
->(
+fn __action1555(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action660(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1310(
-        __temp0,
-        __3,
-        __4,
-    )
+    __action1310(__temp0, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1556<
->(
+fn __action1556(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action661(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1310(
-        __temp0,
-        __4,
-        __5,
-    )
+    __action1310(__temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1557<
->(
+fn __action1557(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(
-        __0,
-    );
+    let __temp0 = __action400(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1311(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action1311(__temp0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1558<
->(
+fn __action1558(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -60291,28 +50198,16 @@ fn __action1558<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Arg, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action660(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1311(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action1311(__temp0, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1559<
->(
+fn __action1559(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -60321,79 +50216,46 @@ fn __action1559<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Arg, TextSize),
     __7: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action661(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1311(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action1311(__temp0, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1560<
->(
+fn __action1560(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(
-        __0,
-    );
+    let __temp0 = __action400(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1312(
-        __temp0,
-        __1,
-        __2,
-        __3,
-    )
+    __action1312(__temp0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1561<
->(
+fn __action1561(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action660(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1312(
-        __temp0,
-        __3,
-        __4,
-        __5,
-    )
+    __action1312(__temp0, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1562<
->(
+fn __action1562(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -60401,139 +50263,84 @@ fn __action1562<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action661(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1312(
-        __temp0,
-        __4,
-        __5,
-        __6,
-    )
+    __action1312(__temp0, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1563<
->(
+fn __action1563(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(
-        __0,
-    );
+    let __temp0 = __action400(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1313(
-        __temp0,
-    )
+    __action1313(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1564<
->(
+fn __action1564(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action660(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1313(
-        __temp0,
-    )
+    __action1313(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1565<
->(
+fn __action1565(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action661(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1313(
-        __temp0,
-    )
+    __action1313(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1566<
->(
+fn __action1566(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(
-        __0,
-    );
+    let __temp0 = __action400(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1314(
-        __temp0,
-        __1,
-        __2,
-        __3,
-    )
+    __action1314(__temp0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1567<
->(
+fn __action1567(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action660(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1314(
-        __temp0,
-        __3,
-        __4,
-        __5,
-    )
+    __action1314(__temp0, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1568<
->(
+fn __action1568(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -60541,101 +50348,60 @@ fn __action1568<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action661(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1314(
-        __temp0,
-        __4,
-        __5,
-        __6,
-    )
+    __action1314(__temp0, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1569<
->(
+fn __action1569(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(
-        __0,
-    );
+    let __temp0 = __action400(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1315(
-        __temp0,
-        __1,
-        __2,
-    )
+    __action1315(__temp0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1570<
->(
+fn __action1570(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action660(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1315(
-        __temp0,
-        __3,
-        __4,
-    )
+    __action1315(__temp0, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1571<
->(
+fn __action1571(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action661(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1315(
-        __temp0,
-        __4,
-        __5,
-    )
+    __action1315(__temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1572<
->(
+fn __action1572(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -60643,28 +50409,16 @@ fn __action1572<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(
-        __0,
-    );
+    let __temp0 = __action408(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1334(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action1334(__temp0, __1, __2, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1573<
->(
+fn __action1573(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -60674,30 +50428,16 @@ fn __action1573<
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __8: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(
-        __0,
-        __1,
-        __2,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1334(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1574<
->(
+    let __temp0 = __action668(__0, __1, __2);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1334(__temp0, __3, __4, __5, __6, __7, __8)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1574(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -60708,58 +50448,32 @@ fn __action1574<
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __9: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1334(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-        __9,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1575<
->(
+    let __temp0 = __action669(__0, __1, __2, __3);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1334(__temp0, __4, __5, __6, __7, __8, __9)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1575(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(
-        __0,
-    );
+    let __temp0 = __action408(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1335(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action1335(__temp0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1576<
->(
+fn __action1576(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -60768,29 +50482,16 @@ fn __action1576<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action668(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1335(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action1335(__temp0, __3, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1577<
->(
+fn __action1577(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -60800,30 +50501,16 @@ fn __action1577<
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __8: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1335(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1578<
->(
+    let __temp0 = __action669(__0, __1, __2, __3);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1335(__temp0, __4, __5, __6, __7, __8)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1578(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -60832,29 +50519,16 @@ fn __action1578<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(
-        __0,
-    );
+    let __temp0 = __action408(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1336(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action1336(__temp0, __1, __2, __3, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1579<
->(
+fn __action1579(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -60865,31 +50539,16 @@ fn __action1579<
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __9: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(
-        __0,
-        __1,
-        __2,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1336(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-        __9,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1580<
->(
+    let __temp0 = __action668(__0, __1, __2);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1336(__temp0, __3, __4, __5, __6, __7, __8, __9)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1580(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -60901,32 +50560,16 @@ fn __action1580<
     __8: (TextSize, token::Tok, TextSize),
     __9: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __10: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1336(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-        __9,
-        __10,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1581<
->(
+    let __temp0 = __action669(__0, __1, __2, __3);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1336(__temp0, __4, __5, __6, __7, __8, __9, __10)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1581(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -60934,28 +50577,16 @@ fn __action1581<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(
-        __0,
-    );
+    let __temp0 = __action408(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1337(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action1337(__temp0, __1, __2, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1582<
->(
+fn __action1582(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -60965,30 +50596,16 @@ fn __action1582<
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __8: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(
-        __0,
-        __1,
-        __2,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1337(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1583<
->(
+    let __temp0 = __action668(__0, __1, __2);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1337(__temp0, __3, __4, __5, __6, __7, __8)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1583(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -60999,56 +50616,31 @@ fn __action1583<
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __9: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1337(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-        __9,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1584<
->(
+    let __temp0 = __action669(__0, __1, __2, __3);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1337(__temp0, __4, __5, __6, __7, __8, __9)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1584(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(
-        __0,
-    );
+    let __temp0 = __action408(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1338(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action1338(__temp0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1585<
->(
+fn __action1585(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -61056,28 +50648,16 @@ fn __action1585<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Arg, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action668(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1338(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action1338(__temp0, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1586<
->(
+fn __action1586(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -61086,79 +50666,46 @@ fn __action1586<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Arg, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action669(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1338(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action1338(__temp0, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1587<
->(
+fn __action1587(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(
-        __0,
-    );
+    let __temp0 = __action408(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1339(
-        __temp0,
-        __1,
-        __2,
-        __3,
-    )
+    __action1339(__temp0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1588<
->(
+fn __action1588(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action668(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1339(
-        __temp0,
-        __3,
-        __4,
-        __5,
-    )
+    __action1339(__temp0, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1589<
->(
+fn __action1589(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -61166,55 +50713,32 @@ fn __action1589<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action669(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1339(
-        __temp0,
-        __4,
-        __5,
-        __6,
-    )
+    __action1339(__temp0, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1590<
->(
+fn __action1590(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(
-        __0,
-    );
+    let __temp0 = __action408(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1340(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action1340(__temp0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1591<
->(
+fn __action1591(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -61223,29 +50747,16 @@ fn __action1591<
     __5: (TextSize, ast::Arg, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action668(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1340(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action1340(__temp0, __3, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1592<
->(
+fn __action1592(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -61255,55 +50766,31 @@ fn __action1592<
     __6: (TextSize, ast::Arg, TextSize),
     __7: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __8: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1340(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1593<
->(
+    let __temp0 = __action669(__0, __1, __2, __3);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1340(__temp0, __4, __5, __6, __7, __8)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1593(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(
-        __0,
-    );
+    let __temp0 = __action408(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1341(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action1341(__temp0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1594<
->(
+fn __action1594(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -61311,28 +50798,16 @@ fn __action1594<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action668(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1341(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action1341(__temp0, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1595<
->(
+fn __action1595(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -61341,123 +50816,73 @@ fn __action1595<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action669(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1341(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action1341(__temp0, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1596<
->(
+fn __action1596(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(
-        __0,
-    );
+    let __temp0 = __action408(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1342(
-        __temp0,
-        __1,
-    )
+    __action1342(__temp0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1597<
->(
+fn __action1597(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action668(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1342(
-        __temp0,
-        __3,
-    )
+    __action1342(__temp0, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1598<
->(
+fn __action1598(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action669(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1342(
-        __temp0,
-        __4,
-    )
+    __action1342(__temp0, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1599<
->(
+fn __action1599(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(
-        __0,
-    );
+    let __temp0 = __action408(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1343(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action1343(__temp0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1600<
->(
+fn __action1600(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -61466,29 +50891,16 @@ fn __action1600<
     __5: (TextSize, ast::Arg, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action668(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1343(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action1343(__temp0, __3, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1601<
->(
+fn __action1601(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -61498,55 +50910,31 @@ fn __action1601<
     __6: (TextSize, ast::Arg, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1343(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1602<
->(
+    let __temp0 = __action669(__0, __1, __2, __3);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1343(__temp0, __4, __5, __6, __7, __8)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1602(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(
-        __0,
-    );
+    let __temp0 = __action408(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1344(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action1344(__temp0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1603<
->(
+fn __action1603(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -61554,28 +50942,16 @@ fn __action1603<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action668(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1344(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action1344(__temp0, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1604<
->(
+fn __action1604(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -61584,29 +50960,16 @@ fn __action1604<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action669(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1344(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action1344(__temp0, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1605<
->(
+fn __action1605(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -61614,28 +50977,16 @@ fn __action1605<
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(
-        __0,
-    );
+    let __temp0 = __action408(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1345(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action1345(__temp0, __1, __2, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1606<
->(
+fn __action1606(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -61645,30 +50996,16 @@ fn __action1606<
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(
-        __0,
-        __1,
-        __2,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1345(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1607<
->(
+    let __temp0 = __action668(__0, __1, __2);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1345(__temp0, __3, __4, __5, __6, __7, __8)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1607(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -61679,58 +51016,32 @@ fn __action1607<
     __7: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __8: (TextSize, token::Tok, TextSize),
     __9: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1345(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-        __9,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1608<
->(
+    let __temp0 = __action669(__0, __1, __2, __3);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1345(__temp0, __4, __5, __6, __7, __8, __9)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1608(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(
-        __0,
-    );
+    let __temp0 = __action408(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1346(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-        __5,
-    )
+    __action1346(__temp0, __1, __2, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1609<
->(
+fn __action1609(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -61739,29 +51050,16 @@ fn __action1609<
     __5: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action668(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1346(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action1346(__temp0, __3, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1610<
->(
+fn __action1610(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -61771,80 +51069,46 @@ fn __action1610<
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1346(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-    )
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1611<
->(
+    let __temp0 = __action669(__0, __1, __2, __3);
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1346(__temp0, __4, __5, __6, __7, __8)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1611(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(
-        __0,
-    );
+    let __temp0 = __action408(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1347(
-        __temp0,
-        __1,
-        __2,
-        __3,
-    )
+    __action1347(__temp0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1612<
->(
+fn __action1612(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Arg, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action668(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1347(
-        __temp0,
-        __3,
-        __4,
-        __5,
-    )
+    __action1347(__temp0, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1613<
->(
+fn __action1613(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -61852,126 +51116,75 @@ fn __action1613<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Arg, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action669(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1347(
-        __temp0,
-        __4,
-        __5,
-        __6,
-    )
+    __action1347(__temp0, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1614<
->(
+fn __action1614(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(
-        __0,
-    );
+    let __temp0 = __action408(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1348(
-        __temp0,
-        __1,
-        __2,
-    )
+    __action1348(__temp0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1615<
->(
+fn __action1615(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action668(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1348(
-        __temp0,
-        __3,
-        __4,
-    )
+    __action1348(__temp0, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1616<
->(
+fn __action1616(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action669(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1348(
-        __temp0,
-        __4,
-        __5,
-    )
+    __action1348(__temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1617<
->(
+fn __action1617(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(
-        __0,
-    );
+    let __temp0 = __action408(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1349(
-        __temp0,
-        __1,
-        __2,
-        __3,
-        __4,
-    )
+    __action1349(__temp0, __1, __2, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1618<
->(
+fn __action1618(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -61979,28 +51192,16 @@ fn __action1618<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Arg, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action668(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1349(
-        __temp0,
-        __3,
-        __4,
-        __5,
-        __6,
-    )
+    __action1349(__temp0, __3, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1619<
->(
+fn __action1619(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -62009,79 +51210,46 @@ fn __action1619<
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Arg, TextSize),
     __7: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action669(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1349(
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-    )
+    __action1349(__temp0, __4, __5, __6, __7)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1620<
->(
+fn __action1620(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(
-        __0,
-    );
+    let __temp0 = __action408(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1350(
-        __temp0,
-        __1,
-        __2,
-        __3,
-    )
+    __action1350(__temp0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1621<
->(
+fn __action1621(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action668(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1350(
-        __temp0,
-        __3,
-        __4,
-        __5,
-    )
+    __action1350(__temp0, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1622<
->(
+fn __action1622(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -62089,139 +51257,84 @@ fn __action1622<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action669(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1350(
-        __temp0,
-        __4,
-        __5,
-        __6,
-    )
+    __action1350(__temp0, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1623<
->(
+fn __action1623(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(
-        __0,
-    );
+    let __temp0 = __action408(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1351(
-        __temp0,
-    )
+    __action1351(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1624<
->(
+fn __action1624(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action668(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1351(
-        __temp0,
-    )
+    __action1351(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1625<
->(
+fn __action1625(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action669(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1351(
-        __temp0,
-    )
+    __action1351(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1626<
->(
+fn __action1626(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(
-        __0,
-    );
+    let __temp0 = __action408(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1352(
-        __temp0,
-        __1,
-        __2,
-        __3,
-    )
+    __action1352(__temp0, __1, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1627<
->(
+fn __action1627(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action668(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1352(
-        __temp0,
-        __3,
-        __4,
-        __5,
-    )
+    __action1352(__temp0, __3, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1628<
->(
+fn __action1628(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -62229,501 +51342,292 @@ fn __action1628<
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action669(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1352(
-        __temp0,
-        __4,
-        __5,
-        __6,
-    )
+    __action1352(__temp0, __4, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1629<
->(
+fn __action1629(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(
-        __0,
-    );
+    let __temp0 = __action408(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1353(
-        __temp0,
-        __1,
-        __2,
-    )
+    __action1353(__temp0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1630<
->(
+fn __action1630(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(
-        __0,
-        __1,
-        __2,
-    );
+    let __temp0 = __action668(__0, __1, __2);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1353(
-        __temp0,
-        __3,
-        __4,
-    )
+    __action1353(__temp0, __3, __4)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1631<
->(
+fn __action1631(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(
-        __0,
-        __1,
-        __2,
-        __3,
-    );
+    let __temp0 = __action669(__0, __1, __2, __3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1353(
-        __temp0,
-        __4,
-        __5,
-    )
+    __action1353(__temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1632<
->(
+fn __action1632(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arguments, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action248(
-        __1,
-    );
+    let __temp0 = __action248(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1269(
-        __0,
-        __temp0,
-        __2,
-        __3,
-    )
+    __action1269(__0, __temp0, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1633<
->(
+fn __action1633(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
-{
+) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action249(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action249(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1269(
-        __0,
-        __temp0,
-        __1,
-        __2,
-    )
+    __action1269(__0, __temp0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1634<
->(
+fn __action1634(
     __0: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __3: (TextSize, Option<ast::Expr>, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action244(
-        __3,
-    );
+    let __temp0 = __action244(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1397(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action1397(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1635<
->(
+fn __action1635(
     __0: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Expr>, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action245(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action245(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1397(
-        __0,
-        __1,
-        __2,
-        __temp0,
-    )
+    __action1397(__0, __1, __2, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1636<
->(
+fn __action1636(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler
-{
+) -> ast::ExceptHandler {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action290(
-        __1,
-    );
+    let __temp0 = __action290(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action763(
-        __0,
-        __temp0,
-        __2,
-        __3,
-    )
+    __action763(__0, __temp0, __2, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1637<
->(
+fn __action1637(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler
-{
+) -> ast::ExceptHandler {
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action291(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action291(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action763(
-        __0,
-        __temp0,
-        __1,
-        __2,
-    )
+    __action763(__0, __temp0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1638<
->(
+fn __action1638(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> Option<ast::Expr>
-{
+) -> Option<ast::Expr> {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action290(
-        __1,
-    );
+    let __temp0 = __action290(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action880(
-        __0,
-        __temp0,
-    )
+    __action880(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1639<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> Option<ast::Expr>
-{
+fn __action1639(__0: (TextSize, token::Tok, TextSize)) -> Option<ast::Expr> {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action291(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action291(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action880(
-        __0,
-        __temp0,
-    )
+    __action880(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1640<
->(
+fn __action1640(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, Option<ast::Expr>, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.2;
     let __start1 = __2.0;
     let __end1 = __2.2;
-    let __temp0 = __action290(
-        __0,
-    );
+    let __temp0 = __action290(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    let __temp1 = __action290(
-        __2,
-    );
+    let __temp1 = __action290(__2);
     let __temp1 = (__start1, __temp1, __end1);
-    __action1634(
-        __temp0,
-        __1,
-        __temp1,
-        __3,
-    )
+    __action1634(__temp0, __1, __temp1, __3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1641<
->(
+fn __action1641(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<ast::Expr>, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.2;
     let __start1 = __1.2;
     let __end1 = __2.0;
-    let __temp0 = __action290(
-        __0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    let __temp1 = __action291(
-        &__start1,
-        &__end1,
-    );
+    let __temp0 = __action290(__0);
+    let __temp0 = (__start0, __temp0, __end0);
+    let __temp1 = __action291(&__start1, &__end1);
     let __temp1 = (__start1, __temp1, __end1);
-    __action1634(
-        __temp0,
-        __1,
-        __temp1,
-        __2,
-    )
+    __action1634(__temp0, __1, __temp1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1642<
->(
+fn __action1642(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Option<ast::Expr>, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
     let __start1 = __1.0;
     let __end1 = __1.2;
-    let __temp0 = __action291(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    let __temp1 = __action290(
-        __1,
-    );
+    let __temp0 = __action291(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    let __temp1 = __action290(__1);
     let __temp1 = (__start1, __temp1, __end1);
-    __action1634(
-        __temp0,
-        __0,
-        __temp1,
-        __2,
-    )
+    __action1634(__temp0, __0, __temp1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1643<
->(
+fn __action1643(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Option<ast::Expr>, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
     let __start1 = __0.2;
     let __end1 = __1.0;
-    let __temp0 = __action291(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    let __temp1 = __action291(
-        &__start1,
-        &__end1,
-    );
+    let __temp0 = __action291(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    let __temp1 = __action291(&__start1, &__end1);
     let __temp1 = (__start1, __temp1, __end1);
-    __action1634(
-        __temp0,
-        __0,
-        __temp1,
-        __1,
-    )
+    __action1634(__temp0, __0, __temp1, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1644<
->(
+fn __action1644(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.2;
     let __start1 = __2.0;
     let __end1 = __2.2;
-    let __temp0 = __action290(
-        __0,
-    );
+    let __temp0 = __action290(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    let __temp1 = __action290(
-        __2,
-    );
+    let __temp1 = __action290(__2);
     let __temp1 = (__start1, __temp1, __end1);
-    __action1635(
-        __temp0,
-        __1,
-        __temp1,
-    )
+    __action1635(__temp0, __1, __temp1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1645<
->(
+fn __action1645(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.2;
     let __start1 = __1.2;
     let __end1 = __1.2;
-    let __temp0 = __action290(
-        __0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    let __temp1 = __action291(
-        &__start1,
-        &__end1,
-    );
+    let __temp0 = __action290(__0);
+    let __temp0 = (__start0, __temp0, __end0);
+    let __temp1 = __action291(&__start1, &__end1);
     let __temp1 = (__start1, __temp1, __end1);
-    __action1635(
-        __temp0,
-        __1,
-        __temp1,
-    )
+    __action1635(__temp0, __1, __temp1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1646<
->(
+fn __action1646(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
     let __start1 = __1.0;
     let __end1 = __1.2;
-    let __temp0 = __action291(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    let __temp1 = __action290(
-        __1,
-    );
+    let __temp0 = __action291(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    let __temp1 = __action290(__1);
     let __temp1 = (__start1, __temp1, __end1);
-    __action1635(
-        __temp0,
-        __0,
-        __temp1,
-    )
+    __action1635(__temp0, __0, __temp1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1647<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+fn __action1647(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.0;
     let __start1 = __0.2;
     let __end1 = __0.2;
-    let __temp0 = __action291(
-        &__start0,
-        &__end0,
-    );
-    let __temp0 = (__start0, __temp0, __end0);
-    let __temp1 = __action291(
-        &__start1,
-        &__end1,
-    );
+    let __temp0 = __action291(&__start0, &__end0);
+    let __temp0 = (__start0, __temp0, __end0);
+    let __temp1 = __action291(&__start1, &__end1);
     let __temp1 = (__start1, __temp1, __end1);
-    __action1635(
-        __temp0,
-        __0,
-        __temp1,
-    )
+    __action1635(__temp0, __0, __temp1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1648<
->(
+fn __action1648(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -62734,31 +51638,16 @@ fn __action1648<
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, token::Tok, TextSize),
     __9: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action210(
-        __4,
-    );
+    let __temp0 = __action210(__4);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1070(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __5,
-        __6,
-        __7,
-        __8,
-        __9,
-    )
+    __action1070(__0, __1, __2, __3, __temp0, __5, __6, __7, __8, __9)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1649<
->(
+fn __action1649(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -62766,28 +51655,16 @@ fn __action1649<
     __4: (TextSize, ast::Expr, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action210(
-        __4,
-    );
+    let __temp0 = __action210(__4);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1071(
-        __0,
-        __1,
-        __2,
-        __3,
-        __temp0,
-        __5,
-        __6,
-    )
+    __action1071(__0, __1, __2, __3, __temp0, __5, __6)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1650<
->(
+fn __action1650(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -62797,293 +51674,185 @@ fn __action1650<
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action210(
-        __3,
-    );
+    let __temp0 = __action210(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1072(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __4,
-        __5,
-        __6,
-        __7,
-        __8,
-    )
+    __action1072(__0, __1, __2, __temp0, __4, __5, __6, __7, __8)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1651<
->(
+fn __action1651(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action210(
-        __3,
-    );
+    let __temp0 = __action210(__3);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1073(
-        __0,
-        __1,
-        __2,
-        __temp0,
-        __4,
-        __5,
-    )
+    __action1073(__0, __1, __2, __temp0, __4, __5)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1652<
->(
-    __0: (TextSize, ast::Expr, TextSize),
-) -> core::option::Option<ast::Expr>
-{
+fn __action1652(__0: (TextSize, ast::Expr, TextSize)) -> core::option::Option<ast::Expr> {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action210(
-        __0,
-    );
+    let __temp0 = __action210(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action355(
-        __temp0,
-    )
+    __action355(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1653<
->(
-    __0: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action1653(__0: (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action210(
-        __0,
-    );
+    let __temp0 = __action210(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action28(
-        __temp0,
-    )
+    __action28(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1654<
->(
-    __0: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+fn __action1654(__0: (TextSize, ast::Expr, TextSize)) -> ast::Expr {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action210(
-        __0,
-    );
+    let __temp0 = __action210(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action30(
-        __temp0,
-    )
+    __action30(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1655<
->(
+fn __action1655(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Mod
-{
+) -> ast::Mod {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action210(
-        __1,
-    );
+    let __temp0 = __action210(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1408(
-        __0,
-        __temp0,
-    )
+    __action1408(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1656<
->(
+fn __action1656(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<token::Tok>, TextSize),
-) -> ast::Mod
-{
+) -> ast::Mod {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action210(
-        __1,
-    );
+    let __temp0 = __action210(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1409(
-        __0,
-        __temp0,
-        __2,
-    )
+    __action1409(__0, __temp0, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1657<
->(
+fn __action1657(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action1652(
-        __1,
-    );
+    let __temp0 = __action1652(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1248(
-        __0,
-        __temp0,
-    )
+    __action1248(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1658<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> ast::Stmt
-{
+fn __action1658(__0: (TextSize, token::Tok, TextSize)) -> ast::Stmt {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action356(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action356(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1248(
-        __0,
-        __temp0,
-    )
+    __action1248(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1659<
->(
+fn __action1659(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr
-{
+) -> ast::Expr {
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action1652(
-        __1,
-    );
+    let __temp0 = __action1652(__1);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1430(
-        __0,
-        __temp0,
-    )
+    __action1430(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1660<
->(
-    __0: (TextSize, token::Tok, TextSize),
-) -> ast::Expr
-{
+fn __action1660(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action356(
-        &__start0,
-        &__end0,
-    );
+    let __temp0 = __action356(&__start0, &__end0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1430(
-        __0,
-        __temp0,
-    )
+    __action1430(__0, __temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1661<
->(
-    __0: (TextSize, ast::Expr, TextSize),
-) -> ast::Stmt
-{
+fn __action1661(__0: (TextSize, ast::Expr, TextSize)) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action1654(
-        __0,
-    );
+    let __temp0 = __action1654(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1454(
-        __temp0,
-    )
+    __action1454(__temp0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1662<
->(
+fn __action1662(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action1654(
-        __0,
-    );
+    let __temp0 = __action1654(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1455(
-        __temp0,
-        __1,
-    )
+    __action1455(__temp0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1663<
->(
+fn __action1663(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Stmt
-{
+) -> ast::Stmt {
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action1654(
-        __0,
-    );
+    let __temp0 = __action1654(__0);
     let __temp0 = (__start0, __temp0, __end0);
-    __action1242(
-        __temp0,
-        __1,
-        __2,
-    )
+    __action1242(__temp0, __1, __2)
 }
 #[allow(clippy::type_complexity)]
 
-pub trait __ToTriple<>
-{
-    fn to_triple(value: Self) -> Result<(TextSize,token::Tok,TextSize), __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>>;
-}
-
-impl<> __ToTriple<> for (TextSize, token::Tok, TextSize)
-{
-    fn to_triple(value: Self) -> Result<(TextSize,token::Tok,TextSize), __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+pub trait __ToTriple {
+    fn to_triple(
+        value: Self,
+    ) -> Result<
+        (TextSize, token::Tok, TextSize),
+        __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+    >;
+}
+
+impl __ToTriple for (TextSize, token::Tok, TextSize) {
+    fn to_triple(
+        value: Self,
+    ) -> Result<
+        (TextSize, token::Tok, TextSize),
+        __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+    > {
         Ok(value)
     }
 }
-impl<> __ToTriple<> for Result<(TextSize, token::Tok, TextSize), LexicalError>
-{
-    fn to_triple(value: Self) -> Result<(TextSize,token::Tok,TextSize), __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+impl __ToTriple for Result<(TextSize, token::Tok, TextSize), LexicalError> {
+    fn to_triple(
+        value: Self,
+    ) -> Result<
+        (TextSize, token::Tok, TextSize),
+        __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
+    > {
         match value {
             Ok(v) => Ok(v),
             Err(error) => Err(__lalrpop_util::ParseError::User { error }),

From 7b0aeeec4b1341bf6d08698343a9f81e20abc1c3 Mon Sep 17 00:00:00 2001
From: Zanie <contact@zanie.dev>
Date: Mon, 10 Jul 2023 14:00:34 -0500
Subject: [PATCH 3/6] Add stub `type_params` handling for class and function
 definitions

---
 ast/src/source_locator.rs                              | 10 ++++++++++
 parser/src/python.rs                                   |  5 +++++
 ...parser__function__tests__function_kw_only_args.snap |  1 +
 ...on__tests__function_kw_only_args_with_defaults.snap |  1 +
 ...thon_parser__function__tests__function_no_args.snap |  1 +
 ...function__tests__function_pos_and_kw_only_args.snap |  1 +
 ...s__function_pos_and_kw_only_args_with_defaults.snap |  1 +
 ...pos_and_kw_only_args_with_defaults_and_varargs.snap |  1 +
 ...only_args_with_defaults_and_varargs_and_kwargs.snap |  1 +
 ...hon_parser__function__tests__function_pos_args.snap |  1 +
 ...nction__tests__function_pos_args_with_defaults.snap |  1 +
 .../rustpython_parser__parser__tests__parse_class.snap |  5 ++++-
 ...ython_parser__parser__tests__variadic_generics.snap |  1 +
 13 files changed, 29 insertions(+), 1 deletion(-)

diff --git a/ast/src/source_locator.rs b/ast/src/source_locator.rs
index 366c32bb..c0a0f22e 100644
--- a/ast/src/source_locator.rs
+++ b/ast/src/source_locator.rs
@@ -149,6 +149,7 @@ impl crate::fold::Fold<TextRange> for LinearLocator<'_> {
             keywords,
             body,
             decorator_list,
+            type_params,
             range,
         } = node;
         let decorator_list = self.fold(decorator_list)?;
@@ -159,12 +160,15 @@ impl crate::fold::Fold<TextRange> for LinearLocator<'_> {
         let keywords = self.fold(keywords)?;
         let body = self.fold(body)?;
         let range = self.map_user(range, context)?;
+        let type_params = self.fold(type_params)?;
+
         Ok(crate::StmtClassDef {
             name,
             bases,
             keywords,
             body,
             decorator_list,
+            type_params,
             range,
         })
     }
@@ -180,6 +184,7 @@ impl crate::fold::Fold<TextRange> for LinearLocator<'_> {
             returns,
             type_comment,
             range,
+            type_params,
         } = node;
         let decorator_list = self.fold(decorator_list)?;
         let context = self.will_map_user(&range);
@@ -189,6 +194,7 @@ impl crate::fold::Fold<TextRange> for LinearLocator<'_> {
         let returns = self.fold(returns)?;
         let body = self.fold(body)?;
         let type_comment = self.fold(type_comment)?;
+        let type_params = self.fold(type_params)?;
         let range = self.map_user(range, context)?;
         Ok(crate::StmtFunctionDef {
             name,
@@ -196,6 +202,7 @@ impl crate::fold::Fold<TextRange> for LinearLocator<'_> {
             body,
             decorator_list,
             returns,
+            type_params,
             type_comment,
             range,
         })
@@ -211,6 +218,7 @@ impl crate::fold::Fold<TextRange> for LinearLocator<'_> {
             decorator_list,
             returns,
             type_comment,
+            type_params,
             range,
         } = node;
         let decorator_list = self.fold(decorator_list)?;
@@ -221,6 +229,7 @@ impl crate::fold::Fold<TextRange> for LinearLocator<'_> {
         let returns = self.fold(returns)?;
         let body = self.fold(body)?;
         let type_comment = self.fold(type_comment)?;
+        let type_params = self.fold(type_params)?;
         let range = self.map_user(range, context)?;
         Ok(crate::StmtAsyncFunctionDef {
             name,
@@ -229,6 +238,7 @@ impl crate::fold::Fold<TextRange> for LinearLocator<'_> {
             decorator_list,
             returns,
             type_comment,
+            type_params,
             range,
         })
     }
diff --git a/parser/src/python.rs b/parser/src/python.rs
index 4a883e4b..143bdd0d 100644
--- a/parser/src/python.rs
+++ b/parser/src/python.rs
@@ -30685,6 +30685,7 @@ fn __action157(
         let returns = r.map(|x| Box::new(x));
         let end_location = body.last().unwrap().end();
         let type_comment = None;
+        let type_params = Vec::new();
         if is_async.is_some() {
             ast::StmtAsyncFunctionDef {
                 name,
@@ -30693,6 +30694,7 @@ fn __action157(
                 decorator_list,
                 returns,
                 type_comment,
+                type_params,
                 range: (location..end_location).into(),
             }
             .into()
@@ -30704,6 +30706,7 @@ fn __action157(
                 decorator_list,
                 returns,
                 type_comment,
+                type_params,
                 range: (location..end_location).into(),
             }
             .into()
@@ -30842,12 +30845,14 @@ fn __action164(
             None => (vec![], vec![]),
         };
         let end_location = body.last().unwrap().end();
+        let type_params = Vec::new();
         ast::Stmt::ClassDef(ast::StmtClassDef {
             name,
             bases,
             keywords,
             body,
             decorator_list,
+            type_params,
             range: (location..end_location).into(),
         })
     }
diff --git a/parser/src/snapshots/rustpython_parser__function__tests__function_kw_only_args.snap b/parser/src/snapshots/rustpython_parser__function__tests__function_kw_only_args.snap
index d13ceb57..e43df55d 100644
--- a/parser/src/snapshots/rustpython_parser__function__tests__function_kw_only_args.snap
+++ b/parser/src/snapshots/rustpython_parser__function__tests__function_kw_only_args.snap
@@ -65,6 +65,7 @@ Ok(
                 decorator_list: [],
                 returns: None,
                 type_comment: None,
+                type_params: [],
             },
         ),
     ],
diff --git a/parser/src/snapshots/rustpython_parser__function__tests__function_kw_only_args_with_defaults.snap b/parser/src/snapshots/rustpython_parser__function__tests__function_kw_only_args_with_defaults.snap
index a228709a..fd75fc37 100644
--- a/parser/src/snapshots/rustpython_parser__function__tests__function_kw_only_args_with_defaults.snap
+++ b/parser/src/snapshots/rustpython_parser__function__tests__function_kw_only_args_with_defaults.snap
@@ -85,6 +85,7 @@ Ok(
                 decorator_list: [],
                 returns: None,
                 type_comment: None,
+                type_params: [],
             },
         ),
     ],
diff --git a/parser/src/snapshots/rustpython_parser__function__tests__function_no_args.snap b/parser/src/snapshots/rustpython_parser__function__tests__function_no_args.snap
index fa56b395..8619f078 100644
--- a/parser/src/snapshots/rustpython_parser__function__tests__function_no_args.snap
+++ b/parser/src/snapshots/rustpython_parser__function__tests__function_no_args.snap
@@ -28,6 +28,7 @@ Ok(
                 decorator_list: [],
                 returns: None,
                 type_comment: None,
+                type_params: [],
             },
         ),
     ],
diff --git a/parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args.snap b/parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args.snap
index 9ca2f2a5..8fbf8b95 100644
--- a/parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args.snap
+++ b/parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args.snap
@@ -102,6 +102,7 @@ Ok(
                 decorator_list: [],
                 returns: None,
                 type_comment: None,
+                type_params: [],
             },
         ),
     ],
diff --git a/parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args_with_defaults.snap b/parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args_with_defaults.snap
index af889e4d..47a53831 100644
--- a/parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args_with_defaults.snap
+++ b/parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args_with_defaults.snap
@@ -122,6 +122,7 @@ Ok(
                 decorator_list: [],
                 returns: None,
                 type_comment: None,
+                type_params: [],
             },
         ),
     ],
diff --git a/parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args_with_defaults_and_varargs.snap b/parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args_with_defaults_and_varargs.snap
index ae32c655..69ac86b6 100644
--- a/parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args_with_defaults_and_varargs.snap
+++ b/parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args_with_defaults_and_varargs.snap
@@ -131,6 +131,7 @@ Ok(
                 decorator_list: [],
                 returns: None,
                 type_comment: None,
+                type_params: [],
             },
         ),
     ],
diff --git a/parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args_with_defaults_and_varargs_and_kwargs.snap b/parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args_with_defaults_and_varargs_and_kwargs.snap
index 213589fa..ab96ed62 100644
--- a/parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args_with_defaults_and_varargs_and_kwargs.snap
+++ b/parser/src/snapshots/rustpython_parser__function__tests__function_pos_and_kw_only_args_with_defaults_and_varargs_and_kwargs.snap
@@ -140,6 +140,7 @@ Ok(
                 decorator_list: [],
                 returns: None,
                 type_comment: None,
+                type_params: [],
             },
         ),
     ],
diff --git a/parser/src/snapshots/rustpython_parser__function__tests__function_pos_args.snap b/parser/src/snapshots/rustpython_parser__function__tests__function_pos_args.snap
index e5515e2a..78481775 100644
--- a/parser/src/snapshots/rustpython_parser__function__tests__function_pos_args.snap
+++ b/parser/src/snapshots/rustpython_parser__function__tests__function_pos_args.snap
@@ -65,6 +65,7 @@ Ok(
                 decorator_list: [],
                 returns: None,
                 type_comment: None,
+                type_params: [],
             },
         ),
     ],
diff --git a/parser/src/snapshots/rustpython_parser__function__tests__function_pos_args_with_defaults.snap b/parser/src/snapshots/rustpython_parser__function__tests__function_pos_args_with_defaults.snap
index 0c91d69e..aa873314 100644
--- a/parser/src/snapshots/rustpython_parser__function__tests__function_pos_args_with_defaults.snap
+++ b/parser/src/snapshots/rustpython_parser__function__tests__function_pos_args_with_defaults.snap
@@ -85,6 +85,7 @@ Ok(
                 decorator_list: [],
                 returns: None,
                 type_comment: None,
+                type_params: [],
             },
         ),
     ],
diff --git a/parser/src/snapshots/rustpython_parser__parser__tests__parse_class.snap b/parser/src/snapshots/rustpython_parser__parser__tests__parse_class.snap
index c27d250f..457673c1 100644
--- a/parser/src/snapshots/rustpython_parser__parser__tests__parse_class.snap
+++ b/parser/src/snapshots/rustpython_parser__parser__tests__parse_class.snap
@@ -1,6 +1,6 @@
 ---
 source: parser/src/parser.rs
-expression: "parse_program(source, \"<test>\").unwrap()"
+expression: "ast::Suite::parse(source, \"<test>\").unwrap()"
 ---
 [
     ClassDef(
@@ -68,6 +68,7 @@ expression: "parse_program(source, \"<test>\").unwrap()"
                         decorator_list: [],
                         returns: None,
                         type_comment: None,
+                        type_params: [],
                     },
                 ),
                 FunctionDef(
@@ -129,10 +130,12 @@ expression: "parse_program(source, \"<test>\").unwrap()"
                         decorator_list: [],
                         returns: None,
                         type_comment: None,
+                        type_params: [],
                     },
                 ),
             ],
             decorator_list: [],
+            type_params: [],
         },
     ),
 ]
diff --git a/parser/src/snapshots/rustpython_parser__parser__tests__variadic_generics.snap b/parser/src/snapshots/rustpython_parser__parser__tests__variadic_generics.snap
index 8590915a..9a10e289 100644
--- a/parser/src/snapshots/rustpython_parser__parser__tests__variadic_generics.snap
+++ b/parser/src/snapshots/rustpython_parser__parser__tests__variadic_generics.snap
@@ -90,6 +90,7 @@ expression: parse_ast
                 ),
             ),
             type_comment: None,
+            type_params: [],
         },
     ),
 ]

From 30f461b7e9b69ac4e98e4cf5c928534c36f442ce Mon Sep 17 00:00:00 2001
From: Zanie <contact@zanie.dev>
Date: Mon, 10 Jul 2023 14:26:45 -0500
Subject: [PATCH 4/6] Revert formatting changes to `python.rs`

---
 parser/src/python.rs | 27993 +++++++++++++++++++++++++++++------------
 1 file changed, 19611 insertions(+), 8382 deletions(-)

diff --git a/parser/src/python.rs b/parser/src/python.rs
index 143bdd0d..e2d1c9d0 100644
--- a/parser/src/python.rs
+++ b/parser/src/python.rs
@@ -1,21 +1,20 @@
 // auto-generated: "lalrpop 0.20.0"
 // sha3: c39f9711066c6f94aaf93d62d86b41efb4242ddcdcbe5b9d35e5a77a14ff22d6
 use crate::{
-    ast::{self as ast, bigint::BigInt, Ranged},
-    context::set_context,
-    function::{parse_args, validate_arguments, validate_pos_params, ArgumentList},
+    ast::{self as ast, Ranged, bigint::BigInt},
     lexer::{LexicalError, LexicalErrorType},
-    parser::optional_range,
+    function::{ArgumentList, parse_args, validate_pos_params, validate_arguments},
+    context::set_context,
     string::parse_strings,
-    text_size::TextSize,
     token::{self, StringKind},
+    text_size::TextSize, parser::optional_range
 };
 #[allow(unused_extern_crates)]
 extern crate lalrpop_util as __lalrpop_util;
 #[allow(unused_imports)]
 use self::__lalrpop_util::state_machine as __state_machine;
-extern crate alloc;
 extern crate core;
+extern crate alloc;
 
 #[rustfmt::skip]
 #[allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports, unused_parens, clippy::all)]
@@ -28710,64 +28709,68 @@ mod __parse__Top {
 pub use self::__parse__Top::TopParser;
 
 #[allow(clippy::too_many_arguments)]
-fn __action0((_, __0, _): (TextSize, ast::Mod, TextSize)) -> ast::Mod {
+fn __action0<
+>(
+    (_, __0, _): (TextSize, ast::Mod, TextSize),
+) -> ast::Mod
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1(
+fn __action1<
+>(
     (_, start, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
     (_, end, _): (TextSize, TextSize, TextSize),
-) -> ast::Mod {
-    ast::ModModule {
-        body,
-        type_ignores: vec![],
-        range: optional_range(start, end),
-    }
-    .into()
+) -> ast::Mod
+{
+    ast::ModModule { body, type_ignores: vec![], range: optional_range(start, end) }.into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action2(
+fn __action2<
+>(
     (_, start, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
     (_, end, _): (TextSize, TextSize, TextSize),
-) -> ast::Mod {
-    ast::ModInteractive {
-        body,
-        range: optional_range(start, end),
-    }
-    .into()
+) -> ast::Mod
+{
+    ast::ModInteractive { body, range: optional_range(start, end) }.into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action3(
+fn __action3<
+>(
     (_, start, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, alloc::vec::Vec<token::Tok>, TextSize),
     (_, end, _): (TextSize, TextSize, TextSize),
-) -> ast::Mod {
-    ast::ModExpression {
-        body: Box::new(body),
-        range: optional_range(start, end),
-    }
-    .into()
+) -> ast::Mod
+{
+    ast::ModExpression { body: Box::new(body), range: optional_range(start, end) }.into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action4(__lookbehind: &TextSize, __lookahead: &TextSize) -> ast::Suite {
+fn __action4<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> ast::Suite
+{
     vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action5(
+fn __action5<
+>(
     (_, mut statements, _): (TextSize, ast::Suite, TextSize),
     (_, next, _): (TextSize, ast::Stmt, TextSize),
-) -> ast::Suite {
+) -> ast::Suite
+{
     {
         statements.push(next);
         statements
@@ -28775,13 +28778,15 @@ fn __action5(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action6(
+fn __action6<
+>(
     (_, mut statements, _): (TextSize, ast::Suite, TextSize),
     (_, small, _): (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     (_, last, _): (TextSize, ast::Stmt, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Suite {
+) -> ast::Suite
+{
     {
         statements.extend(small);
         statements.push(last);
@@ -28790,20 +28795,24 @@ fn __action6(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action7(
+fn __action7<
+>(
     (_, s, _): (TextSize, ast::Suite, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Suite {
+) -> ast::Suite
+{
     s
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action8(
+fn __action8<
+>(
     (_, mut statements, _): (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     (_, last, _): (TextSize, ast::Stmt, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Suite {
+) -> ast::Suite
+{
     {
         statements.push(last);
         statements
@@ -28811,22 +28820,26 @@ fn __action8(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action9(
+fn __action9<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, s, _): (TextSize, Vec<ast::Stmt>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Suite {
+) -> ast::Suite
+{
     s
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action10(
+fn __action10<
+>(
     (_, mut head, _): (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     (_, last, _): (TextSize, ast::Stmt, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt> {
+) -> Vec<ast::Stmt>
+{
     {
         head.push(last);
         head
@@ -28834,15 +28847,21 @@ fn __action10(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action11((_, s, _): (TextSize, ast::Stmt, TextSize)) -> Vec<ast::Stmt> {
+fn __action11<
+>(
+    (_, s, _): (TextSize, ast::Stmt, TextSize),
+) -> Vec<ast::Stmt>
+{
     vec![s]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action12(
+fn __action12<
+>(
     (_, mut statements, _): (TextSize, Vec<ast::Stmt>, TextSize),
     (_, next, _): (TextSize, ast::Stmt, TextSize),
-) -> Vec<ast::Stmt> {
+) -> Vec<ast::Stmt>
+{
     {
         statements.push(next);
         statements
@@ -28850,13 +28869,15 @@ fn __action12(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action13(
+fn __action13<
+>(
     (_, mut statements, _): (TextSize, Vec<ast::Stmt>, TextSize),
     (_, small, _): (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     (_, last, _): (TextSize, ast::Stmt, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt> {
+) -> Vec<ast::Stmt>
+{
     {
         statements.extend(small);
         statements.push(last);
@@ -28865,90 +28886,121 @@ fn __action13(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action14((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
+fn __action14<
+>(
+    (_, __0, _): (TextSize, ast::Stmt, TextSize),
+) -> ast::Stmt
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action15((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
+fn __action15<
+>(
+    (_, __0, _): (TextSize, ast::Stmt, TextSize),
+) -> ast::Stmt
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action16((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
+fn __action16<
+>(
+    (_, __0, _): (TextSize, ast::Stmt, TextSize),
+) -> ast::Stmt
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action17((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
+fn __action17<
+>(
+    (_, __0, _): (TextSize, ast::Stmt, TextSize),
+) -> ast::Stmt
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action18((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
+fn __action18<
+>(
+    (_, __0, _): (TextSize, ast::Stmt, TextSize),
+) -> ast::Stmt
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action19((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
+fn __action19<
+>(
+    (_, __0, _): (TextSize, ast::Stmt, TextSize),
+) -> ast::Stmt
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action20((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
+fn __action20<
+>(
+    (_, __0, _): (TextSize, ast::Stmt, TextSize),
+) -> ast::Stmt
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action21((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
+fn __action21<
+>(
+    (_, __0, _): (TextSize, ast::Stmt, TextSize),
+) -> ast::Stmt
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action22(
+fn __action22<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
-        ast::Stmt::Pass(ast::StmtPass {
-            range: (location..end_location).into(),
-        })
+        ast::Stmt::Pass(ast::StmtPass { range: (location..end_location).into() })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action23(
+fn __action23<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, targets, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
-    {
-        ast::Stmt::Delete(ast::StmtDelete {
-            targets: targets
-                .into_iter()
-                .map(|expr| set_context(expr, ast::ExprContext::Del))
-                .collect(),
-            range: (location..end_location).into(),
-        })
+) -> ast::Stmt
+{
+    {
+        ast::Stmt::Delete(
+            ast::StmtDelete { targets: targets.into_iter().map(|expr| set_context(expr, ast::ExprContext::Del)).collect(), range: (location..end_location).into()  }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action24(
+fn __action24<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, expression, _): (TextSize, ast::Expr, TextSize),
     (_, suffix, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
         // Just an expression, no assignment:
         if suffix.is_empty() {
-            ast::Stmt::Expr(ast::StmtExpr {
-                value: Box::new(expression),
-                range: (location..end_location).into(),
-            })
+            ast::Stmt::Expr(
+                ast::StmtExpr { value: Box::new(expression), range: (location..end_location).into() }
+            )
         } else {
             let mut targets = vec![set_context(expression, ast::ExprContext::Store)];
             let mut values = suffix;
@@ -28959,390 +29011,503 @@ fn __action24(
                 targets.push(set_context(target, ast::ExprContext::Store));
             }
 
-            ast::Stmt::Assign(ast::StmtAssign {
-                targets,
-                value,
-                type_comment: None,
-                range: (location..end_location).into(),
-            })
+            ast::Stmt::Assign(
+                ast::StmtAssign { targets, value, type_comment: None, range: (location..end_location).into() }
+            )
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action25(
+fn __action25<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, target, _): (TextSize, ast::Expr, TextSize),
     (_, op, _): (TextSize, ast::Operator, TextSize),
     (_, rhs, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
-    {
-        ast::Stmt::AugAssign(ast::StmtAugAssign {
-            target: Box::new(set_context(target, ast::ExprContext::Store)),
-            op,
-            value: Box::new(rhs),
-            range: (location..end_location).into(),
-        })
+) -> ast::Stmt
+{
+    {
+        ast::Stmt::AugAssign(
+            ast::StmtAugAssign {
+                target: Box::new(set_context(target, ast::ExprContext::Store)),
+                op,
+                value: Box::new(rhs),
+                range: (location..end_location).into()
+            },
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action26(
+fn __action26<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, target, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, annotation, _): (TextSize, ast::Expr, TextSize),
     (_, rhs, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
         let simple = target.is_name_expr();
-        ast::Stmt::AnnAssign(ast::StmtAnnAssign {
-            target: Box::new(set_context(target, ast::ExprContext::Store)),
-            annotation: Box::new(annotation),
-            value: rhs.map(Box::new),
-            simple,
-            range: (location..end_location).into(),
-        })
+        ast::Stmt::AnnAssign(
+            ast::StmtAnnAssign {
+                target: Box::new(set_context(target, ast::ExprContext::Store)),
+                annotation: Box::new(annotation),
+                value: rhs.map(Box::new),
+                simple,
+                range: (location..end_location).into()
+            },
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action27(
+fn __action27<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     e
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action28((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action28<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action29((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action29<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action30((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action30<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action31((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action31<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action32((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action32<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action33((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action33<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action34((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action34<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action35((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action35<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action36((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action36<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action37((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
+fn __action37<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Operator
+{
     ast::Operator::Add
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action38((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
+fn __action38<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Operator
+{
     ast::Operator::Sub
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action39((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
+fn __action39<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Operator
+{
     ast::Operator::Mult
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action40((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
+fn __action40<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Operator
+{
     ast::Operator::MatMult
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action41((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
+fn __action41<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Operator
+{
     ast::Operator::Div
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action42((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
+fn __action42<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Operator
+{
     ast::Operator::Mod
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action43((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
+fn __action43<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Operator
+{
     ast::Operator::BitAnd
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action44((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
+fn __action44<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Operator
+{
     ast::Operator::BitOr
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action45((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
+fn __action45<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Operator
+{
     ast::Operator::BitXor
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action46((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
+fn __action46<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Operator
+{
     ast::Operator::LShift
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action47((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
+fn __action47<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Operator
+{
     ast::Operator::RShift
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action48((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
+fn __action48<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Operator
+{
     ast::Operator::Pow
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action49((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
+fn __action49<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Operator
+{
     ast::Operator::FloorDiv
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action50(
+fn __action50<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
-        ast::Stmt::Break(ast::StmtBreak {
-            range: (location..end_location).into(),
-        })
+
+        ast::Stmt::Break(ast::StmtBreak { range: (location..end_location).into() })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action51(
+fn __action51<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
-        ast::Stmt::Continue(ast::StmtContinue {
-            range: (location..end_location).into(),
-        })
+        ast::Stmt::Continue(ast::StmtContinue { range: (location..end_location).into() })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action52(
+fn __action52<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, value, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
-        ast::Stmt::Return(ast::StmtReturn {
-            value: value.map(Box::new),
-            range: (location..end_location).into(),
-        })
+        ast::Stmt::Return(
+            ast::StmtReturn { value: value.map(Box::new), range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action53(
+fn __action53<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, expression, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
-        ast::Stmt::Expr(ast::StmtExpr {
-            value: Box::new(expression),
-            range: (location..end_location).into(),
-        })
+        ast::Stmt::Expr(
+            ast::StmtExpr { value: Box::new(expression), range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action54((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
+fn __action54<
+>(
+    (_, __0, _): (TextSize, ast::Stmt, TextSize),
+) -> ast::Stmt
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action55(
+fn __action55<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
-        ast::Stmt::Raise(ast::StmtRaise {
-            exc: None,
-            cause: None,
-            range: (location..end_location).into(),
-        })
+        ast::Stmt::Raise(
+            ast::StmtRaise { exc: None, cause: None, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action56(
+fn __action56<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, t, _): (TextSize, ast::Expr, TextSize),
     (_, c, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
-        ast::Stmt::Raise(ast::StmtRaise {
-            exc: Some(Box::new(t)),
-            cause: c.map(|x| Box::new(x)),
-            range: (location..end_location).into(),
-        })
+        ast::Stmt::Raise(
+            ast::StmtRaise { exc: Some(Box::new(t)), cause: c.map(|x| Box::new(x)), range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action57(
+fn __action57<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, names, _): (TextSize, Vec<ast::Alias>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
-        ast::Stmt::Import(ast::StmtImport {
-            names,
-            range: (location..end_location).into(),
-        })
+        ast::Stmt::Import(
+            ast::StmtImport { names, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action58(
+fn __action58<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-    (_, source, _): (
-        TextSize,
-        (Option<ast::Int>, Option<ast::Identifier>),
-        TextSize,
-    ),
+    (_, source, _): (TextSize, (Option<ast::Int>, Option<ast::Identifier>), TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, names, _): (TextSize, Vec<ast::Alias>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
         let (level, module) = source;
-        ast::Stmt::ImportFrom(ast::StmtImportFrom {
-            level,
-            module,
-            names,
-            range: (location..end_location).into(),
-        })
+        ast::Stmt::ImportFrom(
+            ast::StmtImportFrom {
+                level,
+                module,
+                names,
+                range: (location..end_location).into()
+            },
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action59(
+fn __action59<
+>(
     (_, dots, _): (TextSize, alloc::vec::Vec<ast::Int>, TextSize),
     (_, name, _): (TextSize, ast::Identifier, TextSize),
-) -> (Option<ast::Int>, Option<ast::Identifier>) {
+) -> (Option<ast::Int>, Option<ast::Identifier>)
+{
     {
-        (
-            Some(ast::Int::new(dots.iter().map(ast::Int::to_u32).sum())),
-            Some(name),
-        )
+        (Some(ast::Int::new(dots.iter().map(ast::Int::to_u32).sum())), Some(name))
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action60(
+fn __action60<
+>(
     (_, dots, _): (TextSize, alloc::vec::Vec<ast::Int>, TextSize),
-) -> (Option<ast::Int>, Option<ast::Identifier>) {
+) -> (Option<ast::Int>, Option<ast::Identifier>)
+{
     {
-        (
-            Some(ast::Int::new(dots.iter().map(ast::Int::to_u32).sum())),
-            None,
-        )
+        (Some(ast::Int::new(dots.iter().map(ast::Int::to_u32).sum())), None)
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action61((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Int {
+fn __action61<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Int
+{
     ast::Int::new(3)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action62((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Int {
+fn __action62<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Int
+{
     ast::Int::new(1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action63(
+fn __action63<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, i, _): (TextSize, Vec<ast::Alias>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Vec<ast::Alias> {
+) -> Vec<ast::Alias>
+{
     i
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action64(
+fn __action64<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, i, _): (TextSize, Vec<ast::Alias>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Vec<ast::Alias> {
+) -> Vec<ast::Alias>
+{
     i
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action65(
+fn __action65<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Vec<ast::Alias> {
+) -> Vec<ast::Alias>
+{
     {
         // Star import all
-        vec![ast::Alias {
-            name: ast::Identifier::new("*"),
-            asname: None,
-            range: (location..end_location).into(),
-        }]
+        vec![ast::Alias { name: ast::Identifier::new("*"), asname: None, range: (location..end_location).into() }]
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action66((_, n, _): (TextSize, String, TextSize)) -> ast::Identifier {
+fn __action66<
+>(
+    (_, n, _): (TextSize, String, TextSize),
+) -> ast::Identifier
+{
     ast::Identifier::new(n)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action67(
+fn __action67<
+>(
     (_, n, _): (TextSize, String, TextSize),
-    (_, n2, _): (
-        TextSize,
-        alloc::vec::Vec<(token::Tok, ast::Identifier)>,
-        TextSize,
-    ),
-) -> ast::Identifier {
+    (_, n2, _): (TextSize, alloc::vec::Vec<(token::Tok, ast::Identifier)>, TextSize),
+) -> ast::Identifier
+{
     {
         let mut r = n.to_string();
         for x in n2 {
@@ -29354,94 +29519,133 @@ fn __action67(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action68(
+fn __action68<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, names, _): (TextSize, Vec<ast::Identifier>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
-        ast::Stmt::Global(ast::StmtGlobal {
-            names,
-            range: (location..end_location).into(),
-        })
+        ast::Stmt::Global(
+            ast::StmtGlobal { names, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action69(
+fn __action69<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, names, _): (TextSize, Vec<ast::Identifier>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
-        ast::Stmt::Nonlocal(ast::StmtNonlocal {
-            names,
-            range: (location..end_location).into(),
-        })
+        ast::Stmt::Nonlocal(
+            ast::StmtNonlocal { names, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action70(
+fn __action70<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, test, _): (TextSize, ast::Expr, TextSize),
     (_, msg, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
-        ast::Stmt::Assert(ast::StmtAssert {
-            test: Box::new(test),
-            msg: msg.map(|e| Box::new(e)),
-            range: (location..end_location).into(),
-        })
+        ast::Stmt::Assert(
+            ast::StmtAssert {
+                test: Box::new(test),
+                msg: msg.map(|e| Box::new(e)),
+                range: (location..end_location).into()
+            }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action71((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
+fn __action71<
+>(
+    (_, __0, _): (TextSize, ast::Stmt, TextSize),
+) -> ast::Stmt
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action72((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
+fn __action72<
+>(
+    (_, __0, _): (TextSize, ast::Stmt, TextSize),
+) -> ast::Stmt
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action73((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
+fn __action73<
+>(
+    (_, __0, _): (TextSize, ast::Stmt, TextSize),
+) -> ast::Stmt
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action74((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
+fn __action74<
+>(
+    (_, __0, _): (TextSize, ast::Stmt, TextSize),
+) -> ast::Stmt
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action75((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
+fn __action75<
+>(
+    (_, __0, _): (TextSize, ast::Stmt, TextSize),
+) -> ast::Stmt
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action76((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
+fn __action76<
+>(
+    (_, __0, _): (TextSize, ast::Stmt, TextSize),
+) -> ast::Stmt
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action77((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
+fn __action77<
+>(
+    (_, __0, _): (TextSize, ast::Stmt, TextSize),
+) -> ast::Stmt
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action78((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> ast::Stmt {
+fn __action78<
+>(
+    (_, __0, _): (TextSize, ast::Stmt, TextSize),
+) -> ast::Stmt
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action79(
+fn __action79<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, subject, _): (TextSize, ast::Expr, TextSize),
@@ -29450,19 +29654,29 @@ fn __action79(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, cases, _): (TextSize, alloc::vec::Vec<ast::MatchCase>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
-        let end_location = cases.last().unwrap().body.last().unwrap().end();
-        ast::Stmt::Match(ast::StmtMatch {
-            subject: Box::new(subject),
-            cases,
-            range: (location..end_location).into(),
-        })
+       let end_location = cases
+            .last()
+            .unwrap()
+            .body
+            .last()
+            .unwrap()
+            .end();
+        ast::Stmt::Match(
+            ast::StmtMatch {
+                subject: Box::new(subject),
+                cases,
+                range: (location..end_location).into()
+            }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action80(
+fn __action80<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, subject, _): (TextSize, ast::Expr, TextSize),
@@ -29472,19 +29686,29 @@ fn __action80(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, cases, _): (TextSize, alloc::vec::Vec<ast::MatchCase>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
-        let end_location = cases.last().unwrap().body.last().unwrap().end();
-        ast::Stmt::Match(ast::StmtMatch {
-            subject: Box::new(subject),
-            cases,
-            range: (location..end_location).into(),
-        })
+       let end_location = cases
+            .last()
+            .unwrap()
+            .body
+            .last()
+            .unwrap()
+            .end();
+        ast::Stmt::Match(
+            ast::StmtMatch {
+                subject: Box::new(subject),
+                cases,
+                range: (location..end_location).into()
+            }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action81(
+fn __action81<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, subjects, _): (TextSize, Vec<ast::Expr>, TextSize),
@@ -29494,30 +29718,43 @@ fn __action81(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, cases, _): (TextSize, alloc::vec::Vec<ast::MatchCase>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Stmt {
-    {
-        let end_location = cases.last().unwrap().body.last().unwrap().end();
-        ast::Stmt::Match(ast::StmtMatch {
-            subject: Box::new(ast::Expr::Tuple(ast::ExprTuple {
-                elts: subjects,
-                ctx: ast::ExprContext::Load,
-                range: (location..end_location).into(),
-            })),
-            cases,
-            range: (location..end_location).into(),
-        })
+) -> ast::Stmt
+{
+    {
+        let end_location = cases
+            .last()
+            .unwrap()
+            .body
+            .last()
+            .unwrap()
+            .end();
+        ast::Stmt::Match(
+            ast::StmtMatch {
+                subject: Box::new(ast::Expr::Tuple(
+                    ast::ExprTuple {
+                        elts: subjects,
+                        ctx: ast::ExprContext::Load,
+                        range: (location..end_location).into()
+                    },
+                )),
+                cases,
+                range: (location..end_location).into()
+            }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action82(
+fn __action82<
+>(
     (_, start, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, pattern, _): (TextSize, ast::Pattern, TextSize),
     (_, guard, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
-) -> ast::MatchCase {
+) -> ast::MatchCase
+{
     {
         // SAFETY: `body` is never empty because it is non-optional and `Suite` matches one or more statements.
         let end = body.last().unwrap().end();
@@ -29525,72 +29762,96 @@ fn __action82(
             pattern,
             guard: guard.map(Box::new),
             body,
-            range: optional_range(start, end),
+            range: optional_range(start, end)
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action83(
+fn __action83<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, guard, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
         guard
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action84(
+fn __action84<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, pattern, _): (TextSize, ast::Pattern, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
-    ast::Pattern::MatchSequence(ast::PatternMatchSequence {
-        patterns: vec![pattern],
-        range: (location..end_location).into(),
-    })
+) -> ast::Pattern
+{
+    ast::Pattern::MatchSequence(
+        ast::PatternMatchSequence {
+            patterns: vec![pattern],
+            range: (location..end_location).into()
+        },
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action85(
+fn __action85<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, patterns, _): (TextSize, Vec<ast::Pattern>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     {
-        ast::Pattern::MatchSequence(ast::PatternMatchSequence {
-            patterns,
-            range: (location..end_location).into(),
-        })
+        ast::Pattern::MatchSequence(
+            ast::PatternMatchSequence {
+                patterns,
+                range: (location..end_location).into()
+            },
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action86((_, pattern, _): (TextSize, ast::Pattern, TextSize)) -> ast::Pattern {
+fn __action86<
+>(
+    (_, pattern, _): (TextSize, ast::Pattern, TextSize),
+) -> ast::Pattern
+{
     pattern
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action87((_, pattern, _): (TextSize, ast::Pattern, TextSize)) -> ast::Pattern {
+fn __action87<
+>(
+    (_, pattern, _): (TextSize, ast::Pattern, TextSize),
+) -> ast::Pattern
+{
     pattern
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action88((_, pattern, _): (TextSize, ast::Pattern, TextSize)) -> ast::Pattern {
+fn __action88<
+>(
+    (_, pattern, _): (TextSize, ast::Pattern, TextSize),
+) -> ast::Pattern
+{
     pattern
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action89(
+fn __action89<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, pattern, _): (TextSize, ast::Pattern, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, name, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Pattern, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Pattern,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     {
         if name.as_str() == "_" {
             Err(LexicalError {
@@ -29598,114 +29859,154 @@ fn __action89(
                 location,
             })?
         } else {
-            Ok(ast::Pattern::MatchAs(ast::PatternMatchAs {
-                pattern: Some(Box::new(pattern)),
-                name: Some(name),
-                range: (location..end_location).into(),
-            }))
+            Ok(ast::Pattern::MatchAs(
+                ast::PatternMatchAs {
+                   pattern: Some(Box::new(pattern)),
+                   name: Some(name),
+                   range: (location..end_location).into()
+                },
+            ))
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action90((_, pattern, _): (TextSize, ast::Pattern, TextSize)) -> ast::Pattern {
+fn __action90<
+>(
+    (_, pattern, _): (TextSize, ast::Pattern, TextSize),
+) -> ast::Pattern
+{
     pattern
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action91(
+fn __action91<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, patterns, _): (TextSize, Vec<ast::Pattern>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     {
-        ast::Pattern::MatchOr(ast::PatternMatchOr {
-            patterns,
-            range: (location..end_location).into(),
-        })
+        ast::Pattern::MatchOr(
+            ast::PatternMatchOr { patterns, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action92((_, node, _): (TextSize, ast::Pattern, TextSize)) -> ast::Pattern {
+fn __action92<
+>(
+    (_, node, _): (TextSize, ast::Pattern, TextSize),
+) -> ast::Pattern
+{
     node
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action93((_, node, _): (TextSize, ast::Pattern, TextSize)) -> ast::Pattern {
+fn __action93<
+>(
+    (_, node, _): (TextSize, ast::Pattern, TextSize),
+) -> ast::Pattern
+{
     node
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action94((_, node, _): (TextSize, ast::Pattern, TextSize)) -> ast::Pattern {
+fn __action94<
+>(
+    (_, node, _): (TextSize, ast::Pattern, TextSize),
+) -> ast::Pattern
+{
     node
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action95((_, node, _): (TextSize, ast::Pattern, TextSize)) -> ast::Pattern {
+fn __action95<
+>(
+    (_, node, _): (TextSize, ast::Pattern, TextSize),
+) -> ast::Pattern
+{
     node
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action96((_, node, _): (TextSize, ast::Pattern, TextSize)) -> ast::Pattern {
+fn __action96<
+>(
+    (_, node, _): (TextSize, ast::Pattern, TextSize),
+) -> ast::Pattern
+{
     node
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action97((_, node, _): (TextSize, ast::Pattern, TextSize)) -> ast::Pattern {
+fn __action97<
+>(
+    (_, node, _): (TextSize, ast::Pattern, TextSize),
+) -> ast::Pattern
+{
     node
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action98((_, node, _): (TextSize, ast::Pattern, TextSize)) -> ast::Pattern {
+fn __action98<
+>(
+    (_, node, _): (TextSize, ast::Pattern, TextSize),
+) -> ast::Pattern
+{
     node
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action99(
+fn __action99<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, pattern, _): (TextSize, ast::Pattern, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     pattern
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action100(
+fn __action100<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     ast::PatternMatchSequence {
         patterns: vec![],
-        range: (location..end_location).into(),
-    }
-    .into()
+        range: (location..end_location).into()
+    }.into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action101(
+fn __action101<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, pattern, _): (TextSize, ast::Pattern, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     {
-        ast::PatternMatchSequence {
-            patterns: vec![pattern],
-            range: (location..end_location).into(),
+            ast::PatternMatchSequence {
+                patterns: vec![pattern],
+                range: (location..end_location).into()
+            }.into()
         }
-        .into()
-    }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action102(
+fn __action102<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, patterns, _): (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
@@ -29713,373 +30014,420 @@ fn __action102(
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     {
         let mut patterns = patterns;
         patterns.push(last);
         ast::PatternMatchSequence {
             patterns,
-            range: (location..end_location).into(),
-        }
-        .into()
+            range: (location..end_location).into()
+        }.into()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action103(
+fn __action103<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, patterns, _): (TextSize, Vec<ast::Pattern>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     ast::PatternMatchSequence {
         patterns,
-        range: (location..end_location).into(),
-    }
-    .into()
+        range: (location..end_location).into()
+    }.into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action104(
+fn __action104<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, name, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     ast::PatternMatchStar {
-        name: if name.as_str() == "_" {
-            None
-        } else {
-            Some(name)
-        },
-        range: (location..end_location).into(),
-    }
-    .into()
+        name: if name.as_str() == "_" { None } else { Some(name) },
+        range: (location..end_location).into()
+    }.into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action105(
+fn __action105<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, value, _): (TextSize, ast::Constant, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Constant(ast::ExprConstant {
-        value,
-        kind: None,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Constant(
+        ast::ExprConstant { value, kind: None, range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action106((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action106<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action107(
+fn __action107<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, operand, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::UnaryOp(ast::ExprUnaryOp {
-        op: ast::UnaryOp::USub,
-        operand: Box::new(operand),
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::UnaryOp(
+        ast::ExprUnaryOp {
+            op: ast::UnaryOp::USub,
+            operand: Box::new(operand),
+            range: (location..end_location).into()
+        }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action108(
+fn __action108<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, left, _): (TextSize, ast::Expr, TextSize),
     (_, op, _): (TextSize, ast::Operator, TextSize),
     (_, right, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::BinOp(ast::ExprBinOp {
-        left: Box::new(left),
-        op,
-        right: Box::new(right),
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::BinOp(
+        ast::ExprBinOp {
+            left: Box::new(left),
+            op,
+            right: Box::new(right),
+            range: (location..end_location).into()
+        }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action109(
+fn __action109<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     ast::PatternMatchSingleton {
         value: ast::Constant::None,
-        range: (location..end_location).into(),
-    }
-    .into()
+        range: (location..end_location).into()
+    }.into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action110(
+fn __action110<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     ast::PatternMatchSingleton {
         value: true.into(),
-        range: (location..end_location).into(),
-    }
-    .into()
+        range: (location..end_location).into()
+    }.into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action111(
+fn __action111<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     ast::PatternMatchSingleton {
         value: false.into(),
-        range: (location..end_location).into(),
-    }
-    .into()
+        range: (location..end_location).into()
+    }.into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action112(
+fn __action112<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, value, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     ast::PatternMatchValue {
         value: Box::new(value),
-        range: (location..end_location).into(),
-    }
-    .into()
+        range: (location..end_location).into()
+    }.into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action113(
+fn __action113<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, value, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     ast::PatternMatchValue {
         value: Box::new(value),
-        range: (location..end_location).into(),
-    }
-    .into()
+        range: (location..end_location).into()
+    }.into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action114(
+fn __action114<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
-    (_, s, _): (
-        TextSize,
-        alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>,
-        TextSize,
-    ),
+    (_, s, _): (TextSize, alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Pattern, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Pattern,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     Ok(ast::PatternMatchValue {
         value: Box::new(parse_strings(s)?),
-        range: (location..end_location).into(),
-    }
-    .into())
+        range: (location..end_location).into()
+    }.into())
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action115(
+fn __action115<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, name, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     ast::PatternMatchAs {
         pattern: None,
-        name: if name.as_str() == "_" {
-            None
-        } else {
-            Some(name)
-        },
-        range: (location..end_location).into(),
-    }
-    .into()
+        name: if name.as_str() == "_" { None } else { Some(name) },
+        range: (location..end_location).into()
+    }.into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action116(
+fn __action116<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, name, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Name(ast::ExprName {
-        id: name,
-        ctx: ast::ExprContext::Load,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Name(
+        ast::ExprName { id: name, ctx: ast::ExprContext::Load, range: (location..end_location).into() },
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action117(
+fn __action117<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, name, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, attr, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Attribute(ast::ExprAttribute {
-        value: Box::new(name),
-        attr,
-        ctx: ast::ExprContext::Load,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Attribute(
+        ast::ExprAttribute {
+            value: Box::new(name),
+            attr,
+            ctx: ast::ExprContext::Load,
+            range: (location..end_location).into()
+        },
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action118(
+fn __action118<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, attr, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Attribute(ast::ExprAttribute {
-        value: Box::new(e),
-        attr,
-        ctx: ast::ExprContext::Load,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Attribute(
+        ast::ExprAttribute {
+            value: Box::new(e),
+            attr,
+            ctx: ast::ExprContext::Load,
+            range: (location..end_location).into()
+        },
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action119(
+fn __action119<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     ast::PatternMatchValue {
-        value: Box::new(e),
-        range: (location..end_location).into(),
-    }
-    .into()
+       value: Box::new(e),
+       range: (location..end_location).into()
+   }.into()
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action120((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action120<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action121((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action121<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action122((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action122<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action123(
+fn __action123<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Constant(ast::ExprConstant {
-        value: ast::Constant::None,
-        kind: None,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Constant(
+        ast::ExprConstant {
+            value: ast::Constant::None,
+            kind: None,
+            range: (location..end_location).into()
+        },
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action124(
+fn __action124<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Constant(ast::ExprConstant {
-        value: true.into(),
-        kind: None,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Constant(
+        ast::ExprConstant {
+            value: true.into(),
+            kind: None,
+            range: (location..end_location).into()
+        },
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action125(
+fn __action125<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Constant(ast::ExprConstant {
-        value: false.into(),
-        kind: None,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Constant(
+        ast::ExprConstant {
+            value: false.into(),
+            kind: None,
+            range: (location..end_location).into()
+        },
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action126(
+fn __action126<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
-    (_, s, _): (
-        TextSize,
-        alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>,
-        TextSize,
-    ),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+    (_, s, _): (TextSize, alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>, TextSize),
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     Ok(parse_strings(s)?)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action127(
+fn __action127<
+>(
     (_, k, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, v, _): (TextSize, ast::Pattern, TextSize),
-) -> (ast::Expr, ast::Pattern) {
+) -> (ast::Expr, ast::Pattern)
+{
     (k, v)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action128(
+fn __action128<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     {
         return ast::PatternMatchMapping {
             keys: vec![],
             patterns: vec![],
             rest: None,
-            range: (location..end_location).into(),
-        }
-        .into();
+            range: (location..end_location).into()
+        }.into();
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action129(
+fn __action129<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     {
-        let (keys, patterns) = e.into_iter().unzip();
+        let (keys, patterns) = e
+            .into_iter()
+            .unzip();
         return ast::PatternMatchMapping {
             keys,
             patterns,
             rest: None,
-            range: (location..end_location).into(),
-        }
-        .into();
+            range: (location..end_location).into()
+        }.into();
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action130(
+fn __action130<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -30087,20 +30435,21 @@ fn __action130(
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     {
         return ast::PatternMatchMapping {
             keys: vec![],
             patterns: vec![],
             rest: Some(rest),
-            range: (location..end_location).into(),
-        }
-        .into();
+            range: (location..end_location).into()
+        }.into();
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action131(
+fn __action131<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
@@ -30110,30 +30459,35 @@ fn __action131(
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     {
-        let (keys, patterns) = e.into_iter().unzip();
+        let (keys, patterns) = e
+            .into_iter()
+            .unzip();
         return ast::PatternMatchMapping {
             keys,
             patterns,
             rest: Some(rest),
-            range: (location..end_location).into(),
-        }
-        .into();
+            range: (location..end_location).into()
+        }.into();
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action132(
+fn __action132<
+>(
     (_, k, _): (TextSize, ast::Identifier, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, v, _): (TextSize, ast::Pattern, TextSize),
-) -> (ast::Identifier, ast::Pattern) {
+) -> (ast::Identifier, ast::Pattern)
+{
     (k, v)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action133(
+fn __action133<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -30143,22 +30497,25 @@ fn __action133(
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     {
-        let (kwd_attrs, kwd_patterns) = kwds.into_iter().unzip();
+        let (kwd_attrs, kwd_patterns) = kwds
+            .into_iter()
+            .unzip();
         ast::PatternMatchClass {
             cls: Box::new(e),
             patterns,
             kwd_attrs,
             kwd_patterns,
-            range: (location..end_location).into(),
-        }
-        .into()
+            range: (location..end_location).into()
+        }.into()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action134(
+fn __action134<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -30166,21 +30523,22 @@ fn __action134(
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     {
         ast::PatternMatchClass {
             cls: Box::new(e),
             patterns,
             kwd_attrs: vec![],
             kwd_patterns: vec![],
-            range: (location..end_location).into(),
-        }
-        .into()
+            range: (location..end_location).into()
+        }.into()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action135(
+fn __action135<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -30188,42 +30546,46 @@ fn __action135(
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     {
-        let (kwd_attrs, kwd_patterns) = kwds.into_iter().unzip();
+         let (kwd_attrs, kwd_patterns) = kwds
+            .into_iter()
+            .unzip();
         ast::PatternMatchClass {
             cls: Box::new(e),
             patterns: vec![],
             kwd_attrs,
             kwd_patterns,
-            range: (location..end_location).into(),
-        }
-        .into()
+            range: (location..end_location).into()
+        }.into()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action136(
+fn __action136<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     {
         ast::PatternMatchClass {
             cls: Box::new(e),
             patterns: vec![],
             kwd_attrs: vec![],
             kwd_patterns: vec![],
-            range: (location..end_location).into(),
-        }
-        .into()
+            range: (location..end_location).into()
+        }.into()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action137(
+fn __action137<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -30233,22 +30595,25 @@ fn __action137(
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     {
-        let (kwd_attrs, kwd_patterns) = kwds.into_iter().unzip();
+        let (kwd_attrs, kwd_patterns) = kwds
+            .into_iter()
+            .unzip();
         ast::PatternMatchClass {
             cls: Box::new(e),
             patterns,
             kwd_attrs,
             kwd_patterns,
-            range: (location..end_location).into(),
-        }
-        .into()
+            range: (location..end_location).into()
+        }.into()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action138(
+fn __action138<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -30256,21 +30621,22 @@ fn __action138(
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     {
         ast::PatternMatchClass {
             cls: Box::new(e),
             patterns,
             kwd_attrs: vec![],
             kwd_patterns: vec![],
-            range: (location..end_location).into(),
-        }
-        .into()
+            range: (location..end_location).into()
+        }.into()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action139(
+fn __action139<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -30278,54 +30644,55 @@ fn __action139(
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     {
-        let (kwd_attrs, kwd_patterns) = kwds.into_iter().unzip();
+         let (kwd_attrs, kwd_patterns) = kwds
+            .into_iter()
+            .unzip();
         ast::PatternMatchClass {
             cls: Box::new(e),
             patterns: vec![],
             kwd_attrs,
             kwd_patterns,
-            range: (location..end_location).into(),
-        }
-        .into()
+            range: (location..end_location).into()
+        }.into()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action140(
+fn __action140<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     {
         ast::PatternMatchClass {
             cls: Box::new(e),
             patterns: vec![],
             kwd_attrs: vec![],
             kwd_patterns: vec![],
-            range: (location..end_location).into(),
-        }
-        .into()
+            range: (location..end_location).into()
+        }.into()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action141(
+fn __action141<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, test, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
-    (_, s2, _): (
-        TextSize,
-        alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>,
-        TextSize,
-    ),
+    (_, s2, _): (TextSize, alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>, TextSize),
     (_, s3, _): (TextSize, core::option::Option<ast::Suite>, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
         // Determine last else:
         let mut last = s3.unwrap_or_default();
@@ -30337,47 +30704,50 @@ fn __action141(
             .end();
         // handle elif:
         for i in s2.into_iter().rev() {
-            let x = ast::Stmt::If(ast::StmtIf {
-                test: Box::new(i.1),
-                body: i.2,
-                orelse: last,
-                range: (i.0..end_location).into(),
-            });
+            let x = ast::Stmt::If(
+                ast::StmtIf { test: Box::new(i.1), body: i.2, orelse: last, range: (i.0..end_location).into() }
+            );
             last = vec![x];
         }
 
-        ast::Stmt::If(ast::StmtIf {
-            test: Box::new(test),
-            body,
-            orelse: last,
-            range: (location..end_location).into(),
-        })
+        ast::Stmt::If(
+            ast::StmtIf { test: Box::new(test), body, orelse: last, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action142(
+fn __action142<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, test, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
     (_, s2, _): (TextSize, core::option::Option<ast::Suite>, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
         let orelse = s2.unwrap_or_default();
-        let end_location = orelse.last().or_else(|| body.last()).unwrap().end();
-        ast::Stmt::While(ast::StmtWhile {
-            test: Box::new(test),
-            body,
-            orelse,
-            range: (location..end_location).into(),
-        })
+        let end_location = orelse
+            .last()
+            .or_else(|| body.last())
+            .unwrap()
+            .end();
+        ast::Stmt::While(
+            ast::StmtWhile {
+                test: Box::new(test),
+                body,
+                orelse,
+                range: (location..end_location).into()
+            },
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action143(
+fn __action143<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, is_async, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -30387,37 +30757,29 @@ fn __action143(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
     (_, orelse, _): (TextSize, core::option::Option<ast::Suite>, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
         let orelse = orelse.unwrap_or_default();
-        let end_location = orelse.last().or_else(|| body.last()).unwrap().end();
+        let end_location = orelse
+            .last()
+            .or_else(|| body.last())
+            .unwrap()
+            .end();
         let target = Box::new(set_context(target, ast::ExprContext::Store));
         let iter = Box::new(iter);
         let type_comment = None;
         if is_async.is_some() {
-            ast::Stmt::AsyncFor(ast::StmtAsyncFor {
-                target,
-                iter,
-                body,
-                orelse,
-                type_comment,
-                range: (location..end_location).into(),
-            })
+            ast::Stmt::AsyncFor(ast::StmtAsyncFor { target, iter, body, orelse, type_comment, range: (location..end_location).into() })
         } else {
-            ast::Stmt::For(ast::StmtFor {
-                target,
-                iter,
-                body,
-                orelse,
-                type_comment,
-                range: (location..end_location).into(),
-            })
+            ast::Stmt::For(ast::StmtFor { target, iter, body, orelse, type_comment, range: (location..end_location).into() })
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action144(
+fn __action144<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -30426,7 +30788,8 @@ fn __action144(
     (_, orelse, _): (TextSize, core::option::Option<ast::Suite>, TextSize),
     (_, finalbody, _): (TextSize, core::option::Option<ast::Suite>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
         let orelse = orelse.unwrap_or_default();
         let finalbody = finalbody.unwrap_or_default();
@@ -30436,18 +30799,21 @@ fn __action144(
             .or_else(|| orelse.last().map(|last| last.end()))
             .or_else(|| handlers.last().map(|last| last.end()))
             .unwrap();
-        ast::Stmt::Try(ast::StmtTry {
-            body,
-            handlers,
-            orelse,
-            finalbody,
-            range: (location..end_location).into(),
-        })
+        ast::Stmt::Try(
+            ast::StmtTry {
+                body,
+                handlers,
+                orelse,
+                finalbody,
+                range: (location..end_location).into()
+            },
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action145(
+fn __action145<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -30456,7 +30822,8 @@ fn __action145(
     (_, orelse, _): (TextSize, core::option::Option<ast::Suite>, TextSize),
     (_, finalbody, _): (TextSize, core::option::Option<ast::Suite>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
         let orelse = orelse.unwrap_or_default();
         let finalbody = finalbody.unwrap_or_default();
@@ -30466,210 +30833,225 @@ fn __action145(
             .map(|last| last.end())
             .or_else(|| handlers.last().map(|last| last.end()))
             .unwrap();
-        ast::Stmt::TryStar(ast::StmtTryStar {
-            body,
-            handlers,
-            orelse,
-            finalbody,
-            range: (location..end_location).into(),
-        })
+        ast::Stmt::TryStar(
+            ast::StmtTryStar {
+                body,
+                handlers,
+                orelse,
+                finalbody,
+                range: (location..end_location).into()
+            },
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action146(
+fn __action146<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
     (_, finalbody, _): (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
         let handlers = vec![];
         let orelse = vec![];
         let end_location = finalbody.last().unwrap().end();
-        ast::Stmt::Try(ast::StmtTry {
-            body,
-            handlers,
-            orelse,
-            finalbody,
-            range: (location..end_location).into(),
-        })
+        ast::Stmt::Try(
+            ast::StmtTry {
+                body,
+                handlers,
+                orelse,
+                finalbody,
+                range: (location..end_location).into()
+            },
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action147(
+fn __action147<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, typ, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler {
+) -> ast::ExceptHandler
+{
     {
         let end_location = body.last().unwrap().end();
-        ast::ExceptHandler::ExceptHandler(ast::ExceptHandlerExceptHandler {
-            type_: Some(Box::new(typ)),
-            name: None,
-            body,
-            range: (location..end_location).into(),
-        })
+        ast::ExceptHandler::ExceptHandler(
+            ast::ExceptHandlerExceptHandler {
+                type_: Some(Box::new(typ)),
+                name: None,
+                body,
+                range: (location..end_location).into()
+            },
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action148(
+fn __action148<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, x, _): (TextSize, (ast::Expr, ast::Identifier), TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler {
+) -> ast::ExceptHandler
+{
     {
         let end_location = body.last().unwrap().end();
-        ast::ExceptHandler::ExceptHandler(ast::ExceptHandlerExceptHandler {
-            type_: Some(Box::new(x.0)),
-            name: Some(x.1),
-            body,
-            range: (location..end_location).into(),
-        })
+        ast::ExceptHandler::ExceptHandler(
+            ast::ExceptHandlerExceptHandler {
+                type_: Some(Box::new(x.0)),
+                name: Some(x.1),
+                body,
+                range: (location..end_location).into()
+            },
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action149(
+fn __action149<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, typ, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler {
+) -> ast::ExceptHandler
+{
     {
         let end_location = body.last().unwrap().end();
-        ast::ExceptHandler::ExceptHandler(ast::ExceptHandlerExceptHandler {
-            type_: typ.map(Box::new),
-            name: None,
-            body,
-            range: (location..end_location).into(),
-        })
+        ast::ExceptHandler::ExceptHandler(
+            ast::ExceptHandlerExceptHandler {
+                type_: typ.map(Box::new),
+                name: None,
+                body,
+                range: (location..end_location).into()
+            },
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action150(
+fn __action150<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, x, _): (TextSize, (ast::Expr, ast::Identifier), TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler {
+) -> ast::ExceptHandler
+{
     {
         let end_location = body.last().unwrap().end();
-        ast::ExceptHandler::ExceptHandler(ast::ExceptHandlerExceptHandler {
-            type_: Some(Box::new(x.0)),
-            name: Some(x.1),
-            body,
-            range: (location..end_location).into(),
-        })
+        ast::ExceptHandler::ExceptHandler(
+            ast::ExceptHandlerExceptHandler {
+                type_: Some(Box::new(x.0)),
+                name: Some(x.1),
+                body,
+                range: (location..end_location).into()
+            },
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action151(
+fn __action151<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, is_async, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, items, _): (TextSize, Vec<ast::WithItem>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
         let end_location = body.last().unwrap().end();
         let type_comment = None;
         if is_async.is_some() {
-            ast::StmtAsyncWith {
-                items,
-                body,
-                type_comment,
-                range: (location..end_location).into(),
-            }
-            .into()
+            ast::StmtAsyncWith { items, body, type_comment, range: (location..end_location).into() }.into()
         } else {
-            ast::StmtWith {
-                items,
-                body,
-                type_comment,
-                range: (location..end_location).into(),
-            }
-            .into()
+            ast::StmtWith { items, body, type_comment, range: (location..end_location).into() }.into()
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action152(
+fn __action152<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, Vec<ast::WithItem>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action153(
+fn __action153<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, left, _): (TextSize, core::option::Option<Vec<ast::WithItem>>, TextSize),
     (_, mid, _): (TextSize, ast::WithItem, TextSize),
     (_, right, _): (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     {
-        left.into_iter()
-            .flatten()
-            .chain([mid])
-            .chain(right)
-            .collect()
+        left.into_iter().flatten().chain([mid]).chain(right).collect()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action154((_, __0, _): (TextSize, ast::WithItem, TextSize)) -> Vec<ast::WithItem> {
+fn __action154<
+>(
+    (_, __0, _): (TextSize, ast::WithItem, TextSize),
+) -> Vec<ast::WithItem>
+{
     vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action155(
+fn __action155<
+>(
     (_, item, _): (TextSize, ast::WithItem, TextSize),
     (_, items, _): (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     {
         [item].into_iter().chain(items).collect()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action156(
+fn __action156<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, all, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     {
-        all.into_iter()
-            .map(|context_expr| ast::WithItem {
-                context_expr,
-                optional_vars: None,
-                range: optional_range(location, end_location),
-            })
-            .collect()
+        all.into_iter().map(|context_expr| ast::WithItem { context_expr, optional_vars: None, range: optional_range(location, end_location) }).collect()
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action157(
+fn __action157<
+>(
     (_, decorator_list, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, is_async, _): (TextSize, core::option::Option<token::Tok>, TextSize),
@@ -30679,7 +31061,8 @@ fn __action157(
     (_, r, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
         let args = Box::new(args);
         let returns = r.map(|x| Box::new(x));
@@ -30687,158 +31070,115 @@ fn __action157(
         let type_comment = None;
         let type_params = Vec::new();
         if is_async.is_some() {
-            ast::StmtAsyncFunctionDef {
-                name,
-                args,
-                body,
-                decorator_list,
-                returns,
-                type_comment,
-                type_params,
-                range: (location..end_location).into(),
-            }
-            .into()
+            ast::StmtAsyncFunctionDef { name, args, body, decorator_list, returns, type_comment, type_params, range: (location..end_location).into() }.into()
         } else {
-            ast::StmtFunctionDef {
-                name,
-                args,
-                body,
-                decorator_list,
-                returns,
-                type_comment,
-                type_params,
-                range: (location..end_location).into(),
-            }
-            .into()
+            ast::StmtFunctionDef { name, args, body, decorator_list, returns, type_comment, type_params, range: (location..end_location).into() }.into()
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action158(
+fn __action158<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, a, _): (TextSize, core::option::Option<ast::Arguments>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     {
         a.as_ref().map(validate_arguments).transpose()?;
-        let args =
-            a.unwrap_or_else(|| ast::Arguments::empty(optional_range(location, end_location)));
+        let args = a
+            .unwrap_or_else(|| ast::Arguments::empty(optional_range(location, end_location)));
 
         Ok(args)
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action159(
+fn __action159<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, arg, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::ArgWithDefault {
+) -> ast::ArgWithDefault
+{
     {
-        let def = ast::Arg {
-            arg,
-            annotation: None,
-            type_comment: None,
-            range: (location..end_location).into(),
-        };
-        ast::ArgWithDefault {
-            def,
-            default: None,
-            range: optional_range(location, end_location),
-        }
+        let def = ast::Arg { arg, annotation: None, type_comment: None, range: (location..end_location).into() };
+        ast::ArgWithDefault { def, default: None, range: optional_range(location, end_location) }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action160(
+fn __action160<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, arg, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Arg {
-    ast::Arg {
-        arg,
-        annotation: None,
-        type_comment: None,
-        range: (location..end_location).into(),
-    }
+) -> ast::Arg
+{
+    ast::Arg { arg, annotation: None, type_comment: None, range: (location..end_location).into() }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action161(
+fn __action161<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, arg, _): (TextSize, ast::Identifier, TextSize),
     (_, a, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::ArgWithDefault {
+) -> ast::ArgWithDefault
+{
     {
         let annotation = a.map(Box::new);
-        let def = ast::Arg {
-            arg,
-            annotation,
-            type_comment: None,
-            range: (location..end_location).into(),
-        };
-        ast::ArgWithDefault {
-            def,
-            default: None,
-            range: optional_range(location, end_location),
-        }
+        let def = ast::Arg { arg, annotation, type_comment: None, range: (location..end_location).into() };
+        ast::ArgWithDefault { def, default: None, range: optional_range(location, end_location) }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action162(
+fn __action162<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, arg, _): (TextSize, ast::Identifier, TextSize),
     (_, a, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Arg {
+) -> ast::Arg
+{
     {
         let annotation = a.map(Box::new);
-        ast::Arg {
-            arg,
-            annotation,
-            type_comment: None,
-            range: (location..end_location).into(),
-        }
+        ast::Arg { arg, annotation, type_comment: None, range: (location..end_location).into() }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action163(
+fn __action163<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, arg, _): (TextSize, ast::Identifier, TextSize),
     (_, a, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Arg {
+) -> ast::Arg
+{
     {
         let annotation = a.map(Box::new);
-        ast::Arg {
-            arg,
-            annotation,
-            type_comment: None,
-            range: (location..end_location).into(),
-        }
+        ast::Arg { arg, annotation, type_comment: None, range: (location..end_location).into() }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action164(
+fn __action164<
+>(
     (_, decorator_list, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, name, _): (TextSize, ast::Identifier, TextSize),
-    (_, a, _): (
-        TextSize,
-        core::option::Option<(token::Tok, ArgumentList, token::Tok)>,
-        TextSize,
-    ),
+    (_, a, _): (TextSize, core::option::Option<(token::Tok, ArgumentList, token::Tok)>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     {
         let (bases, keywords) = match a {
             Some((_, arg, _)) => (arg.args, arg.keywords),
@@ -30846,403 +31186,548 @@ fn __action164(
         };
         let end_location = body.last().unwrap().end();
         let type_params = Vec::new();
-        ast::Stmt::ClassDef(ast::StmtClassDef {
-            name,
-            bases,
-            keywords,
-            body,
-            decorator_list,
-            type_params,
-            range: (location..end_location).into(),
-        })
+        ast::Stmt::ClassDef(
+            ast::StmtClassDef {
+                name,
+                bases,
+                keywords,
+                body,
+                decorator_list,
+                type_params,
+                range: (location..end_location).into()
+            },
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action165(
+fn __action165<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, p, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
         p
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action166(
+fn __action166<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, value, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Yield(ast::ExprYield {
-        value: value.map(Box::new),
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Yield(
+        ast::ExprYield { value: value.map(Box::new), range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action167(
+fn __action167<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::YieldFrom(ast::ExprYieldFrom {
-        value: Box::new(e),
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::YieldFrom(
+        ast::ExprYieldFrom { value: Box::new(e), range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action168((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action168<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action169((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action169<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action170(
+fn __action170<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, id, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, value, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
-    {
-        ast::Expr::NamedExpr(ast::ExprNamedExpr {
-            target: Box::new(ast::Expr::Name(ast::ExprName {
-                id,
-                ctx: ast::ExprContext::Store,
-                range: (location..end_location).into(),
-            })),
-            range: (location..value.end()).into(),
-            value: Box::new(value),
-        })
+) -> ast::Expr
+{
+    {
+        ast::Expr::NamedExpr(
+            ast::ExprNamedExpr {
+                target: Box::new(ast::Expr::Name(
+                    ast::ExprName { id, ctx: ast::ExprContext::Store, range: (location..end_location).into() },
+                )),
+                range: (location..value.end()).into(),
+                value: Box::new(value),
+            }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action171(
+fn __action171<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, p, _): (TextSize, core::option::Option<ast::Arguments>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, body, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     {
         p.as_ref().map(validate_arguments).transpose()?;
-        let p = p.unwrap_or_else(|| ast::Arguments::empty(optional_range(location, end_location)));
+        let p = p
+            .unwrap_or_else(|| ast::Arguments::empty(optional_range(location, end_location)));
 
-        Ok(ast::Expr::Lambda(ast::ExprLambda {
-            args: Box::new(p),
-            body: Box::new(body),
-            range: (location..end_location).into(),
-        }))
+        Ok(ast::Expr::Lambda(
+            ast::ExprLambda {
+                args: Box::new(p),
+                body: Box::new(body),
+                range: (location..end_location).into()
+            }
+        ))
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action172((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::CmpOp {
+fn __action172<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::CmpOp
+{
     ast::CmpOp::Eq
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action173((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::CmpOp {
+fn __action173<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::CmpOp
+{
     ast::CmpOp::NotEq
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action174((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::CmpOp {
+fn __action174<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::CmpOp
+{
     ast::CmpOp::Lt
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action175((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::CmpOp {
+fn __action175<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::CmpOp
+{
     ast::CmpOp::LtE
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action176((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::CmpOp {
+fn __action176<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::CmpOp
+{
     ast::CmpOp::Gt
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action177((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::CmpOp {
+fn __action177<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::CmpOp
+{
     ast::CmpOp::GtE
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action178((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::CmpOp {
+fn __action178<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::CmpOp
+{
     ast::CmpOp::In
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action179(
+fn __action179<
+>(
     (_, __0, _): (TextSize, token::Tok, TextSize),
     (_, __1, _): (TextSize, token::Tok, TextSize),
-) -> ast::CmpOp {
+) -> ast::CmpOp
+{
     ast::CmpOp::NotIn
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action180((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::CmpOp {
+fn __action180<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::CmpOp
+{
     ast::CmpOp::Is
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action181(
+fn __action181<
+>(
     (_, __0, _): (TextSize, token::Tok, TextSize),
     (_, __1, _): (TextSize, token::Tok, TextSize),
-) -> ast::CmpOp {
+) -> ast::CmpOp
+{
     ast::CmpOp::IsNot
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action182((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
+fn __action182<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Operator
+{
     ast::Operator::LShift
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action183((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
+fn __action183<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Operator
+{
     ast::Operator::RShift
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action184((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
+fn __action184<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Operator
+{
     ast::Operator::Add
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action185((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
+fn __action185<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Operator
+{
     ast::Operator::Sub
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action186((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
+fn __action186<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Operator
+{
     ast::Operator::Mult
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action187((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
+fn __action187<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Operator
+{
     ast::Operator::Div
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action188((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
+fn __action188<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Operator
+{
     ast::Operator::FloorDiv
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action189((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
+fn __action189<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Operator
+{
     ast::Operator::Mod
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action190((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::Operator {
+fn __action190<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::Operator
+{
     ast::Operator::MatMult
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action191((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::UnaryOp {
+fn __action191<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::UnaryOp
+{
     ast::UnaryOp::UAdd
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action192((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::UnaryOp {
+fn __action192<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::UnaryOp
+{
     ast::UnaryOp::USub
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action193((_, __0, _): (TextSize, token::Tok, TextSize)) -> ast::UnaryOp {
+fn __action193<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> ast::UnaryOp
+{
     ast::UnaryOp::Invert
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action194(
+fn __action194<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, s1, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
         s1
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action195(
+fn __action195<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, s1, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
-        ast::Expr::Tuple(ast::ExprTuple {
-            elts: vec![s1],
-            ctx: ast::ExprContext::Load,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::Tuple(
+            ast::ExprTuple { elts: vec![s1], ctx: ast::ExprContext::Load, range: (location..end_location).into() },
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action196(
+fn __action196<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, elts, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
-        ast::Expr::Tuple(ast::ExprTuple {
-            elts,
-            ctx: ast::ExprContext::Load,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::Tuple(
+            ast::ExprTuple { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() },
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action197((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action197<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action198(
+fn __action198<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e1, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
     (_, e3, _): (TextSize, core::option::Option<Option<ast::Expr>>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
         let lower = e1.map(Box::new);
         let upper = e2.map(Box::new);
         let step = e3.flatten().map(Box::new);
-        ast::Expr::Slice(ast::ExprSlice {
-            lower,
-            upper,
-            step,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::Slice(
+            ast::ExprSlice { lower, upper, step, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action199(
+fn __action199<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, core::option::Option<ast::Expr>, TextSize),
-) -> Option<ast::Expr> {
+) -> Option<ast::Expr>
+{
     e
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action200(
+fn __action200<
+>(
     (_, e, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
-) -> Vec<ast::Expr> {
+) -> Vec<ast::Expr>
+{
     e
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action201(
+fn __action201<
+>(
     (_, elements, _): (TextSize, Vec<(Option<Box<ast::Expr>>, ast::Expr)>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
-) -> Vec<(Option<Box<ast::Expr>>, ast::Expr)> {
+) -> Vec<(Option<Box<ast::Expr>>, ast::Expr)>
+{
     elements
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action202(
+fn __action202<
+>(
     (_, e1, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, ast::Expr, TextSize),
-) -> (ast::Expr, ast::Expr) {
+) -> (ast::Expr, ast::Expr)
+{
     (e1, e2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action203(
+fn __action203<
+>(
     (_, e, _): (TextSize, (ast::Expr, ast::Expr), TextSize),
-) -> (Option<Box<ast::Expr>>, ast::Expr) {
+) -> (Option<Box<ast::Expr>>, ast::Expr)
+{
     (Some(Box::new(e.0)), e.1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action204(
+fn __action204<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> (Option<Box<ast::Expr>>, ast::Expr) {
+) -> (Option<Box<ast::Expr>>, ast::Expr)
+{
     (None, e)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action205(
+fn __action205<
+>(
     (_, e1, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
-) -> Vec<ast::Expr> {
+) -> Vec<ast::Expr>
+{
     e1
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action206((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action206<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action207((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action207<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action208((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action208<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action209(
+fn __action209<
+>(
     (_, elements, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
-) -> Vec<ast::Expr> {
+) -> Vec<ast::Expr>
+{
     elements
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action210((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action210<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action211(
+fn __action211<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Starred(ast::ExprStarred {
-        value: Box::new(e),
-        ctx: ast::ExprContext::Load,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Starred(
+        ast::ExprStarred { value: Box::new(e), ctx: ast::ExprContext::Load, range: (location..end_location).into() },
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action212(
+fn __action212<
+>(
     (_, c, _): (TextSize, alloc::vec::Vec<ast::Comprehension>, TextSize),
-) -> Vec<ast::Comprehension> {
+) -> Vec<ast::Comprehension>
+{
     c
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action213(
+fn __action213<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, is_async, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -31251,7 +31736,8 @@ fn __action213(
     (_, iter, _): (TextSize, ast::Expr, TextSize),
     (_, ifs, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Comprehension {
+) -> ast::Comprehension
+{
     {
         let is_async = is_async.is_some();
         ast::Comprehension {
@@ -31259,35 +31745,36 @@ fn __action213(
             iter,
             ifs,
             is_async,
-            range: optional_range(location, end_location),
+            range: optional_range(location, end_location)
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action214((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action214<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action215(
+fn __action215<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, c, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     c
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action216(
-    (_, e, _): (
-        TextSize,
-        Vec<(
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        )>,
-        TextSize,
-    ),
-) -> Result<ArgumentList, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+fn __action216<
+>(
+    (_, e, _): (TextSize, Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
+) -> Result<ArgumentList,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     {
         let arg_list = parse_args(e)?;
         Ok(arg_list)
@@ -31295,26 +31782,23 @@ fn __action216(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action217(
+fn __action217<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-    (_, c, _): (
-        TextSize,
-        core::option::Option<Vec<ast::Comprehension>>,
-        TextSize,
-    ),
+    (_, c, _): (TextSize, core::option::Option<Vec<ast::Comprehension>>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> (
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-) {
+) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
+{
     {
         let expr = match c {
-            Some(c) => ast::Expr::GeneratorExp(ast::ExprGeneratorExp {
-                elt: Box::new(e),
-                generators: c,
-                range: (location..end_location).into(),
-            }),
+            Some(c) => ast::Expr::GeneratorExp(
+                ast::ExprGeneratorExp {
+                    elt: Box::new(e),
+                    generators: c,
+                    range: (location..end_location).into()
+                }
+            ),
             None => e,
         };
         (None, expr)
@@ -31322,112 +31806,109 @@ fn __action217(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action218(
+fn __action218<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, i, _): (TextSize, ast::Identifier, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> (
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-) {
+) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
+{
     (Some((location, end_location, Some(i))), e)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action219(
+fn __action219<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> (
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-) {
+) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
+{
     {
-        let expr = ast::Expr::Starred(ast::ExprStarred {
-            value: Box::new(e),
-            ctx: ast::ExprContext::Load,
-            range: (location..end_location).into(),
-        });
+        let expr = ast::Expr::Starred(
+            ast::ExprStarred { value: Box::new(e), ctx: ast::ExprContext::Load, range: (location..end_location).into() },
+        );
         (None, expr)
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action220(
+fn __action220<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> (
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-) {
+) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
+{
     (Some((location, end_location, None)), e)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action221((_, value, _): (TextSize, BigInt, TextSize)) -> ast::Constant {
+fn __action221<
+>(
+    (_, value, _): (TextSize, BigInt, TextSize),
+) -> ast::Constant
+{
     ast::Constant::Int(value)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action222((_, value, _): (TextSize, f64, TextSize)) -> ast::Constant {
+fn __action222<
+>(
+    (_, value, _): (TextSize, f64, TextSize),
+) -> ast::Constant
+{
     ast::Constant::Float(value)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action223((_, s, _): (TextSize, (f64, f64), TextSize)) -> ast::Constant {
-    ast::Constant::Complex {
-        real: s.0,
-        imag: s.1,
-    }
+fn __action223<
+>(
+    (_, s, _): (TextSize, (f64, f64), TextSize),
+) -> ast::Constant
+{
+    ast::Constant::Complex { real: s.0, imag: s.1 }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action224((_, s, _): (TextSize, String, TextSize)) -> ast::Identifier {
+fn __action224<
+>(
+    (_, s, _): (TextSize, String, TextSize),
+) -> ast::Identifier
+{
     ast::Identifier::new(s)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action225(
+fn __action225<
+>(
     (_, __0, _): (TextSize, Vec<ast::Comprehension>, TextSize),
-) -> core::option::Option<Vec<ast::Comprehension>> {
+) -> core::option::Option<Vec<ast::Comprehension>>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action226(
+fn __action226<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<Vec<ast::Comprehension>> {
+) -> core::option::Option<Vec<ast::Comprehension>>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action227(
-    (_, mut v, _): (
-        TextSize,
-        alloc::vec::Vec<(
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        )>,
-        TextSize,
-    ),
-    (_, last, _): (
-        TextSize,
-        core::option::Option<(
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        )>,
-        TextSize,
-    ),
-) -> Vec<(
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-)> {
+fn __action227<
+>(
+    (_, mut v, _): (TextSize, alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
+    (_, last, _): (TextSize, core::option::Option<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
+) -> Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
+{
     {
         if let Some(element) = last {
             v.push(element);
@@ -31437,89 +31918,106 @@ fn __action227(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action228(__lookbehind: &TextSize, __lookahead: &TextSize) -> alloc::vec::Vec<ast::Expr> {
+fn __action228<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> alloc::vec::Vec<ast::Expr>
+{
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action229(
+fn __action229<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
-) -> alloc::vec::Vec<ast::Expr> {
+) -> alloc::vec::Vec<ast::Expr>
+{
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action230(
+fn __action230<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, mut values, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, last, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
         values.push(last);
-        ast::Expr::BoolOp(ast::ExprBoolOp {
-            op: ast::BoolOp::Or,
-            values,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::BoolOp(
+            ast::ExprBoolOp { op: ast::BoolOp::Or, values, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action231((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action231<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action232(
+fn __action232<
+>(
     (_, __0, _): (TextSize, ast::Comprehension, TextSize),
-) -> alloc::vec::Vec<ast::Comprehension> {
+) -> alloc::vec::Vec<ast::Comprehension>
+{
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action233(
+fn __action233<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Comprehension>, TextSize),
     (_, e, _): (TextSize, ast::Comprehension, TextSize),
-) -> alloc::vec::Vec<ast::Comprehension> {
-    {
-        let mut v = v;
-        v.push(e);
-        v
-    }
+) -> alloc::vec::Vec<ast::Comprehension>
+{
+    { let mut v = v; v.push(e); v }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action234(
+fn __action234<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, elts, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, trailing_comma, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
         if elts.len() == 1 && trailing_comma.is_none() {
             elts.into_iter().next().unwrap()
         } else {
-            ast::Expr::Tuple(ast::ExprTuple {
-                elts,
-                ctx: ast::ExprContext::Load,
-                range: (location..end_location).into(),
-            })
+            ast::Expr::Tuple(
+                ast::ExprTuple { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() }
+            )
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action235((_, e, _): (TextSize, ast::Expr, TextSize)) -> Vec<ast::Expr> {
+fn __action235<
+>(
+    (_, e, _): (TextSize, ast::Expr, TextSize),
+) -> Vec<ast::Expr>
+{
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action236(
+fn __action236<
+>(
     (_, mut v, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> Vec<ast::Expr> {
+) -> Vec<ast::Expr>
+{
     {
         v.push(e);
         v
@@ -31527,59 +32025,66 @@ fn __action236(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action237(
+fn __action237<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, elts, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, trailing_comma, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
         if elts.len() == 1 && trailing_comma.is_none() {
             elts.into_iter().next().unwrap()
         } else {
-            ast::Expr::Tuple(ast::ExprTuple {
-                elts,
-                ctx: ast::ExprContext::Load,
-                range: (location..end_location).into(),
-            })
+            ast::Expr::Tuple(
+                ast::ExprTuple { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() }
+            )
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action238(
+fn __action238<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e1, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::BinOp(ast::ExprBinOp {
-        left: Box::new(e1),
-        op: ast::Operator::BitOr,
-        right: Box::new(e2),
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::BinOp(
+        ast::ExprBinOp { left: Box::new(e1), op: ast::Operator::BitOr, right: Box::new(e2), range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action239((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action239<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action240(
+fn __action240<
+>(
     (_, e, _): (TextSize, (Option<Box<ast::Expr>>, ast::Expr), TextSize),
-) -> Vec<(Option<Box<ast::Expr>>, ast::Expr)> {
+) -> Vec<(Option<Box<ast::Expr>>, ast::Expr)>
+{
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action241(
+fn __action241<
+>(
     (_, mut v, _): (TextSize, Vec<(Option<Box<ast::Expr>>, ast::Expr)>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, (Option<Box<ast::Expr>>, ast::Expr), TextSize),
-) -> Vec<(Option<Box<ast::Expr>>, ast::Expr)> {
+) -> Vec<(Option<Box<ast::Expr>>, ast::Expr)>
+{
     {
         v.push(e);
         v
@@ -31587,16 +32092,22 @@ fn __action241(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action242((_, e, _): (TextSize, ast::Expr, TextSize)) -> Vec<ast::Expr> {
+fn __action242<
+>(
+    (_, e, _): (TextSize, ast::Expr, TextSize),
+) -> Vec<ast::Expr>
+{
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action243(
+fn __action243<
+>(
     (_, mut v, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> Vec<ast::Expr> {
+) -> Vec<ast::Expr>
+{
     {
         v.push(e);
         v
@@ -31604,35 +32115,43 @@ fn __action243(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action244(
+fn __action244<
+>(
     (_, __0, _): (TextSize, Option<ast::Expr>, TextSize),
-) -> core::option::Option<Option<ast::Expr>> {
+) -> core::option::Option<Option<ast::Expr>>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action245(
+fn __action245<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<Option<ast::Expr>> {
+) -> core::option::Option<Option<ast::Expr>>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action246(
+fn __action246<
+>(
     (_, e1, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, ast::Expr, TextSize),
-) -> Vec<ast::Expr> {
+) -> Vec<ast::Expr>
+{
     vec![e1, e2]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action247(
+fn __action247<
+>(
     (_, mut v, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> Vec<ast::Expr> {
+) -> Vec<ast::Expr>
+{
     {
         v.push(e);
         v
@@ -31640,40 +32159,34 @@ fn __action247(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action248(
+fn __action248<
+>(
     (_, __0, _): (TextSize, ast::Arguments, TextSize),
-) -> core::option::Option<ast::Arguments> {
+) -> core::option::Option<ast::Arguments>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action249(
+fn __action249<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<ast::Arguments> {
+) -> core::option::Option<ast::Arguments>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action250(
+fn __action250<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
-    (_, param1, _): (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
-    (_, args2, _): (
-        TextSize,
-        core::option::Option<(
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        )>,
-        TextSize,
-    ),
+    (_, param1, _): (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+    (_, args2, _): (TextSize, core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     {
         validate_pos_params(&param1)?;
         let (posonlyargs, args) = param1;
@@ -31687,23 +32200,21 @@ fn __action250(
             kwonlyargs,
             vararg,
             kwarg,
-            range: optional_range(location, end_location),
+            range: optional_range(location, end_location)
         })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action251(
+fn __action251<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
-    (_, param1, _): (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+    (_, param1, _): (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     (_, kw, _): (TextSize, Option<Box<ast::Arg>>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     {
         validate_pos_params(&param1)?;
         let (posonlyargs, args) = param1;
@@ -31719,26 +32230,20 @@ fn __action251(
             kwonlyargs,
             vararg,
             kwarg,
-            range: optional_range(location, end_location),
+            range: optional_range(location, end_location)
         })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action252(
+fn __action252<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
-    (_, params, _): (
-        TextSize,
-        (
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        ),
-        TextSize,
-    ),
+    (_, params, _): (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Arguments {
+) -> ast::Arguments
+{
     {
         let (vararg, kwonlyargs, kwarg) = params;
         ast::Arguments {
@@ -31747,18 +32252,20 @@ fn __action252(
             kwonlyargs,
             vararg,
             kwarg,
-            range: optional_range(location, end_location),
+            range: optional_range(location, end_location)
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action253(
+fn __action253<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, kwarg, _): (TextSize, Option<Box<ast::Arg>>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Arguments {
+) -> ast::Arguments
+{
     {
         ast::Arguments {
             posonlyargs: vec![],
@@ -31766,111 +32273,137 @@ fn __action253(
             kwonlyargs: vec![],
             vararg: None,
             kwarg,
-            range: optional_range(location, end_location),
+            range: optional_range(location, end_location)
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action254(
+fn __action254<
+>(
     (_, __0, _): (TextSize, (token::Tok, ArgumentList, token::Tok), TextSize),
-) -> core::option::Option<(token::Tok, ArgumentList, token::Tok)> {
+) -> core::option::Option<(token::Tok, ArgumentList, token::Tok)>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action255(
+fn __action255<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<(token::Tok, ArgumentList, token::Tok)> {
+) -> core::option::Option<(token::Tok, ArgumentList, token::Tok)>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action256(
+fn __action256<
+>(
     (_, __0, _): (TextSize, token::Tok, TextSize),
     (_, __1, _): (TextSize, ArgumentList, TextSize),
     (_, __2, _): (TextSize, token::Tok, TextSize),
-) -> (token::Tok, ArgumentList, token::Tok) {
+) -> (token::Tok, ArgumentList, token::Tok)
+{
     (__0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action257((_, __0, _): (TextSize, ast::Expr, TextSize)) -> core::option::Option<ast::Expr> {
+fn __action257<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> core::option::Option<ast::Expr>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action258(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Expr> {
+fn __action258<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> core::option::Option<ast::Expr>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action259(
+fn __action259<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action260((_, __0, _): (TextSize, ast::Expr, TextSize)) -> core::option::Option<ast::Expr> {
+fn __action260<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> core::option::Option<ast::Expr>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action261(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Expr> {
+fn __action261<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> core::option::Option<ast::Expr>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action262(
+fn __action262<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action263(
+fn __action263<
+>(
     (_, __0, _): (TextSize, ast::Arguments, TextSize),
-) -> core::option::Option<ast::Arguments> {
+) -> core::option::Option<ast::Arguments>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action264(
+fn __action264<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<ast::Arguments> {
+) -> core::option::Option<ast::Arguments>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action265((_, __0, _): (TextSize, ast::Arguments, TextSize)) -> ast::Arguments {
+fn __action265<
+>(
+    (_, __0, _): (TextSize, ast::Arguments, TextSize),
+) -> ast::Arguments
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action266(
+fn __action266<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
-    (_, param1, _): (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
-    (_, args2, _): (
-        TextSize,
-        core::option::Option<(
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        )>,
-        TextSize,
-    ),
+    (_, param1, _): (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+    (_, args2, _): (TextSize, core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     {
         validate_pos_params(&param1)?;
         let (posonlyargs, args) = param1;
@@ -31884,23 +32417,21 @@ fn __action266(
             kwonlyargs,
             vararg,
             kwarg,
-            range: optional_range(location, end_location),
+            range: optional_range(location, end_location)
         })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action267(
+fn __action267<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
-    (_, param1, _): (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+    (_, param1, _): (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     (_, kw, _): (TextSize, Option<Box<ast::Arg>>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     {
         validate_pos_params(&param1)?;
         let (posonlyargs, args) = param1;
@@ -31916,26 +32447,20 @@ fn __action267(
             kwonlyargs,
             vararg,
             kwarg,
-            range: optional_range(location, end_location),
+            range: optional_range(location, end_location)
         })
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action268(
+fn __action268<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
-    (_, params, _): (
-        TextSize,
-        (
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        ),
-        TextSize,
-    ),
+    (_, params, _): (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Arguments {
+) -> ast::Arguments
+{
     {
         let (vararg, kwonlyargs, kwarg) = params;
         ast::Arguments {
@@ -31944,18 +32469,20 @@ fn __action268(
             kwonlyargs,
             vararg,
             kwarg,
-            range: optional_range(location, end_location),
+            range: optional_range(location, end_location)
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action269(
+fn __action269<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, kwarg, _): (TextSize, Option<Box<ast::Arg>>, TextSize),
     (_, _, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Arguments {
+) -> ast::Arguments
+{
     {
         ast::Arguments {
             posonlyargs: vec![],
@@ -31963,52 +32490,76 @@ fn __action269(
             kwonlyargs: vec![],
             vararg: None,
             kwarg,
-            range: optional_range(location, end_location),
+            range: optional_range(location, end_location)
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action270((_, __0, _): (TextSize, ast::Expr, TextSize)) -> core::option::Option<ast::Expr> {
+fn __action270<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> core::option::Option<ast::Expr>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action271(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Expr> {
+fn __action271<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> core::option::Option<ast::Expr>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action272(
+fn __action272<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action273(__lookbehind: &TextSize, __lookahead: &TextSize) -> alloc::vec::Vec<ast::Expr> {
+fn __action273<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> alloc::vec::Vec<ast::Expr>
+{
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action274(
+fn __action274<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
-) -> alloc::vec::Vec<ast::Expr> {
+) -> alloc::vec::Vec<ast::Expr>
+{
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action275((_, e, _): (TextSize, ast::Expr, TextSize)) -> Vec<ast::Expr> {
+fn __action275<
+>(
+    (_, e, _): (TextSize, ast::Expr, TextSize),
+) -> Vec<ast::Expr>
+{
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action276(
+fn __action276<
+>(
     (_, mut v, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> Vec<ast::Expr> {
+) -> Vec<ast::Expr>
+{
     {
         v.push(e);
         v
@@ -32016,302 +32567,348 @@ fn __action276(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action277((_, __0, _): (TextSize, ast::WithItem, TextSize)) -> alloc::vec::Vec<ast::WithItem> {
+fn __action277<
+>(
+    (_, __0, _): (TextSize, ast::WithItem, TextSize),
+) -> alloc::vec::Vec<ast::WithItem>
+{
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action278(
+fn __action278<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
     (_, e, _): (TextSize, ast::WithItem, TextSize),
-) -> alloc::vec::Vec<ast::WithItem> {
-    {
-        let mut v = v;
-        v.push(e);
-        v
-    }
+) -> alloc::vec::Vec<ast::WithItem>
+{
+    { let mut v = v; v.push(e); v }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action279(
+fn __action279<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, context_expr, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::WithItem {
-    ast::WithItem {
-        context_expr,
-        optional_vars: None,
-        range: optional_range(location, end_location),
-    }
+) -> ast::WithItem
+{
+    ast::WithItem { context_expr, optional_vars: None, range: optional_range(location, end_location) }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action280(
+fn __action280<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, context_expr, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, vars, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::WithItem {
+) -> ast::WithItem
+{
     {
         let optional_vars = Some(Box::new(set_context(vars, ast::ExprContext::Store)));
-        ast::WithItem {
-            context_expr,
-            optional_vars,
-            range: optional_range(location, end_location),
-        }
+        ast::WithItem { context_expr, optional_vars, range: optional_range(location, end_location) }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action281(__lookbehind: &TextSize, __lookahead: &TextSize) -> alloc::vec::Vec<ast::WithItem> {
+fn __action281<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> alloc::vec::Vec<ast::WithItem>
+{
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action282(
+fn __action282<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
-) -> alloc::vec::Vec<ast::WithItem> {
+) -> alloc::vec::Vec<ast::WithItem>
+{
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action283(
+fn __action283<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::WithItem, TextSize),
-) -> ast::WithItem {
+) -> ast::WithItem
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action284(
+fn __action284<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, context_expr, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::WithItem {
-    ast::WithItem {
-        context_expr,
-        optional_vars: None,
-        range: optional_range(location, end_location),
-    }
+) -> ast::WithItem
+{
+    ast::WithItem { context_expr, optional_vars: None, range: optional_range(location, end_location) }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action285(
+fn __action285<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, context_expr, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, vars, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::WithItem {
+) -> ast::WithItem
+{
     {
         let optional_vars = Some(Box::new(set_context(vars, ast::ExprContext::Store)));
-        ast::WithItem {
-            context_expr,
-            optional_vars,
-            range: optional_range(location, end_location),
-        }
+        ast::WithItem { context_expr, optional_vars, range: optional_range(location, end_location) }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action286(
+fn __action286<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, context_expr, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, vars, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::WithItem {
+) -> ast::WithItem
+{
     {
         let optional_vars = Some(Box::new(set_context(vars, ast::ExprContext::Store)));
-        ast::WithItem {
-            context_expr,
-            optional_vars,
-            range: optional_range(location, end_location),
-        }
+        ast::WithItem { context_expr, optional_vars, range: optional_range(location, end_location) }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action287(
+fn __action287<
+>(
     (_, __0, _): (TextSize, Vec<ast::WithItem>, TextSize),
-) -> core::option::Option<Vec<ast::WithItem>> {
+) -> core::option::Option<Vec<ast::WithItem>>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action288(
+fn __action288<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<Vec<ast::WithItem>> {
+) -> core::option::Option<Vec<ast::WithItem>>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action289(
+fn __action289<
+>(
     (_, __0, _): (TextSize, Vec<ast::WithItem>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action290((_, __0, _): (TextSize, ast::Expr, TextSize)) -> core::option::Option<ast::Expr> {
+fn __action290<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> core::option::Option<ast::Expr>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action291(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Expr> {
+fn __action291<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> core::option::Option<ast::Expr>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action292(
+fn __action292<
+>(
     (_, __0, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __1, _): (TextSize, ast::Identifier, TextSize),
-) -> (ast::Expr, ast::Identifier) {
+) -> (ast::Expr, ast::Identifier)
+{
     (__0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action293(
+fn __action293<
+>(
     (_, __0, _): (TextSize, ast::ExceptHandler, TextSize),
-) -> alloc::vec::Vec<ast::ExceptHandler> {
+) -> alloc::vec::Vec<ast::ExceptHandler>
+{
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action294(
+fn __action294<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::ExceptHandler>, TextSize),
     (_, e, _): (TextSize, ast::ExceptHandler, TextSize),
-) -> alloc::vec::Vec<ast::ExceptHandler> {
-    {
-        let mut v = v;
-        v.push(e);
-        v
-    }
+) -> alloc::vec::Vec<ast::ExceptHandler>
+{
+    { let mut v = v; v.push(e); v }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action295((_, __0, _): (TextSize, ast::Suite, TextSize)) -> core::option::Option<ast::Suite> {
+fn __action295<
+>(
+    (_, __0, _): (TextSize, ast::Suite, TextSize),
+) -> core::option::Option<ast::Suite>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action296(
+fn __action296<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<ast::Suite> {
+) -> core::option::Option<ast::Suite>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action297(
+fn __action297<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::Suite, TextSize),
-) -> ast::Suite {
+) -> ast::Suite
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action298(
+fn __action298<
+>(
     (_, __0, _): (TextSize, ast::ExceptHandler, TextSize),
-) -> alloc::vec::Vec<ast::ExceptHandler> {
+) -> alloc::vec::Vec<ast::ExceptHandler>
+{
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action299(
+fn __action299<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::ExceptHandler>, TextSize),
     (_, e, _): (TextSize, ast::ExceptHandler, TextSize),
-) -> alloc::vec::Vec<ast::ExceptHandler> {
-    {
-        let mut v = v;
-        v.push(e);
-        v
-    }
+) -> alloc::vec::Vec<ast::ExceptHandler>
+{
+    { let mut v = v; v.push(e); v }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action300((_, __0, _): (TextSize, token::Tok, TextSize)) -> core::option::Option<token::Tok> {
+fn __action300<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> core::option::Option<token::Tok>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action301(
+fn __action301<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<token::Tok> {
+) -> core::option::Option<token::Tok>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action302((_, __0, _): (TextSize, ast::Suite, TextSize)) -> core::option::Option<ast::Suite> {
+fn __action302<
+>(
+    (_, __0, _): (TextSize, ast::Suite, TextSize),
+) -> core::option::Option<ast::Suite>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action303(
+fn __action303<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<ast::Suite> {
+) -> core::option::Option<ast::Suite>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action304(
+fn __action304<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::Suite, TextSize),
-) -> ast::Suite {
+) -> ast::Suite
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action305(
+fn __action305<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)> {
+) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>
+{
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action306(
-    (_, v, _): (
-        TextSize,
-        alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>,
-        TextSize,
-    ),
-) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)> {
+fn __action306<
+>(
+    (_, v, _): (TextSize, alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>, TextSize),
+) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>
+{
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action307(
+fn __action307<
+>(
     (_, __0, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __1, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __2, _): (TextSize, ast::Suite, TextSize),
-) -> (TextSize, ast::Expr, ast::Suite) {
+) -> (TextSize, ast::Expr, ast::Suite)
+{
     (__0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action308(
+fn __action308<
+>(
     (_, e, _): (TextSize, (ast::Identifier, ast::Pattern), TextSize),
-) -> Vec<(ast::Identifier, ast::Pattern)> {
+) -> Vec<(ast::Identifier, ast::Pattern)>
+{
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action309(
+fn __action309<
+>(
     (_, mut v, _): (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, (ast::Identifier, ast::Pattern), TextSize),
-) -> Vec<(ast::Identifier, ast::Pattern)> {
+) -> Vec<(ast::Identifier, ast::Pattern)>
+{
     {
         v.push(e);
         v
@@ -32319,16 +32916,22 @@ fn __action309(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action310((_, e, _): (TextSize, ast::Pattern, TextSize)) -> Vec<ast::Pattern> {
+fn __action310<
+>(
+    (_, e, _): (TextSize, ast::Pattern, TextSize),
+) -> Vec<ast::Pattern>
+{
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action311(
+fn __action311<
+>(
     (_, mut v, _): (TextSize, Vec<ast::Pattern>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Pattern, TextSize),
-) -> Vec<ast::Pattern> {
+) -> Vec<ast::Pattern>
+{
     {
         v.push(e);
         v
@@ -32336,18 +32939,22 @@ fn __action311(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action312(
+fn __action312<
+>(
     (_, e, _): (TextSize, (ast::Expr, ast::Pattern), TextSize),
-) -> Vec<(ast::Expr, ast::Pattern)> {
+) -> Vec<(ast::Expr, ast::Pattern)>
+{
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action313(
+fn __action313<
+>(
     (_, mut v, _): (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, (ast::Expr, ast::Pattern), TextSize),
-) -> Vec<(ast::Expr, ast::Pattern)> {
+) -> Vec<(ast::Expr, ast::Pattern)>
+{
     {
         v.push(e);
         v
@@ -32355,50 +32962,42 @@ fn __action313(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action314(
-    (_, __0, _): (
-        TextSize,
-        (TextSize, (String, StringKind, bool), TextSize),
-        TextSize,
-    ),
-) -> alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)> {
+fn __action314<
+>(
+    (_, __0, _): (TextSize, (TextSize, (String, StringKind, bool), TextSize), TextSize),
+) -> alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>
+{
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action315(
-    (_, v, _): (
-        TextSize,
-        alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>,
-        TextSize,
-    ),
-    (_, e, _): (
-        TextSize,
-        (TextSize, (String, StringKind, bool), TextSize),
-        TextSize,
-    ),
-) -> alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)> {
-    {
-        let mut v = v;
-        v.push(e);
-        v
-    }
+fn __action315<
+>(
+    (_, v, _): (TextSize, alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>, TextSize),
+    (_, e, _): (TextSize, (TextSize, (String, StringKind, bool), TextSize), TextSize),
+) -> alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>
+{
+    { let mut v = v; v.push(e); v }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action316(
+fn __action316<
+>(
     (_, __0, _): (TextSize, TextSize, TextSize),
     (_, __1, _): (TextSize, (String, StringKind, bool), TextSize),
     (_, __2, _): (TextSize, TextSize, TextSize),
-) -> (TextSize, (String, StringKind, bool), TextSize) {
+) -> (TextSize, (String, StringKind, bool), TextSize)
+{
     (__0, __1, __2)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action317(
+fn __action317<
+>(
     (_, mut v, _): (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     (_, last, _): (TextSize, core::option::Option<ast::Pattern>, TextSize),
-) -> Vec<ast::Pattern> {
+) -> Vec<ast::Pattern>
+{
     {
         if let Some(element) = last {
             v.push(element);
@@ -32408,45 +33007,53 @@ fn __action317(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action318((_, __0, _): (TextSize, ast::Pattern, TextSize)) -> alloc::vec::Vec<ast::Pattern> {
+fn __action318<
+>(
+    (_, __0, _): (TextSize, ast::Pattern, TextSize),
+) -> alloc::vec::Vec<ast::Pattern>
+{
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action319(
+fn __action319<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     (_, e, _): (TextSize, ast::Pattern, TextSize),
-) -> alloc::vec::Vec<ast::Pattern> {
-    {
-        let mut v = v;
-        v.push(e);
-        v
-    }
+) -> alloc::vec::Vec<ast::Pattern>
+{
+    { let mut v = v; v.push(e); v }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action320(
+fn __action320<
+>(
     (_, __0, _): (TextSize, ast::Pattern, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action321(
+fn __action321<
+>(
     (_, e1, _): (TextSize, ast::Pattern, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, ast::Pattern, TextSize),
-) -> Vec<ast::Pattern> {
+) -> Vec<ast::Pattern>
+{
     vec![e1, e2]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action322(
+fn __action322<
+>(
     (_, mut v, _): (TextSize, Vec<ast::Pattern>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Pattern, TextSize),
-) -> Vec<ast::Pattern> {
+) -> Vec<ast::Pattern>
+{
     {
         v.push(e);
         v
@@ -32454,20 +33061,24 @@ fn __action322(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action323(
+fn __action323<
+>(
     (_, e1, _): (TextSize, ast::Pattern, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, ast::Pattern, TextSize),
-) -> Vec<ast::Pattern> {
+) -> Vec<ast::Pattern>
+{
     vec![e1, e2]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action324(
+fn __action324<
+>(
     (_, mut v, _): (TextSize, Vec<ast::Pattern>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Pattern, TextSize),
-) -> Vec<ast::Pattern> {
+) -> Vec<ast::Pattern>
+{
     {
         v.push(e);
         v
@@ -32475,35 +33086,52 @@ fn __action324(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action325((_, __0, _): (TextSize, ast::Expr, TextSize)) -> core::option::Option<ast::Expr> {
+fn __action325<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> core::option::Option<ast::Expr>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action326(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Expr> {
+fn __action326<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> core::option::Option<ast::Expr>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action327((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action327<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action328(
+fn __action328<
+>(
     (_, e1, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, ast::Expr, TextSize),
-) -> Vec<ast::Expr> {
+) -> Vec<ast::Expr>
+{
     vec![e1, e2]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action329(
+fn __action329<
+>(
     (_, mut v, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> Vec<ast::Expr> {
+) -> Vec<ast::Expr>
+{
     {
         v.push(e);
         v
@@ -32511,53 +33139,70 @@ fn __action329(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action330(
+fn __action330<
+>(
     (_, __0, _): (TextSize, ast::MatchCase, TextSize),
-) -> alloc::vec::Vec<ast::MatchCase> {
+) -> alloc::vec::Vec<ast::MatchCase>
+{
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action331(
+fn __action331<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::MatchCase>, TextSize),
     (_, e, _): (TextSize, ast::MatchCase, TextSize),
-) -> alloc::vec::Vec<ast::MatchCase> {
-    {
-        let mut v = v;
-        v.push(e);
-        v
-    }
+) -> alloc::vec::Vec<ast::MatchCase>
+{
+    { let mut v = v; v.push(e); v }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action332((_, __0, _): (TextSize, ast::Expr, TextSize)) -> core::option::Option<ast::Expr> {
+fn __action332<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> core::option::Option<ast::Expr>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action333(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Expr> {
+fn __action333<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> core::option::Option<ast::Expr>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action334(
+fn __action334<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action335((_, e, _): (TextSize, ast::Identifier, TextSize)) -> Vec<ast::Identifier> {
+fn __action335<
+>(
+    (_, e, _): (TextSize, ast::Identifier, TextSize),
+) -> Vec<ast::Identifier>
+{
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action336(
+fn __action336<
+>(
     (_, mut v, _): (TextSize, Vec<ast::Identifier>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Identifier, TextSize),
-) -> Vec<ast::Identifier> {
+) -> Vec<ast::Identifier>
+{
     {
         v.push(e);
         v
@@ -32565,60 +33210,70 @@ fn __action336(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action337(
+fn __action337<
+>(
     (_, __0, _): (TextSize, (token::Tok, ast::Identifier), TextSize),
-) -> alloc::vec::Vec<(token::Tok, ast::Identifier)> {
+) -> alloc::vec::Vec<(token::Tok, ast::Identifier)>
+{
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action338(
-    (_, v, _): (
-        TextSize,
-        alloc::vec::Vec<(token::Tok, ast::Identifier)>,
-        TextSize,
-    ),
+fn __action338<
+>(
+    (_, v, _): (TextSize, alloc::vec::Vec<(token::Tok, ast::Identifier)>, TextSize),
     (_, e, _): (TextSize, (token::Tok, ast::Identifier), TextSize),
-) -> alloc::vec::Vec<(token::Tok, ast::Identifier)> {
-    {
-        let mut v = v;
-        v.push(e);
-        v
-    }
+) -> alloc::vec::Vec<(token::Tok, ast::Identifier)>
+{
+    { let mut v = v; v.push(e); v }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action339(
+fn __action339<
+>(
     (_, __0, _): (TextSize, token::Tok, TextSize),
     (_, __1, _): (TextSize, ast::Identifier, TextSize),
-) -> (token::Tok, ast::Identifier) {
+) -> (token::Tok, ast::Identifier)
+{
     (__0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action340((_, __0, _): (TextSize, token::Tok, TextSize)) -> core::option::Option<token::Tok> {
+fn __action340<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> core::option::Option<token::Tok>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action341(
+fn __action341<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<token::Tok> {
+) -> core::option::Option<token::Tok>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action342((_, e, _): (TextSize, ast::Alias, TextSize)) -> Vec<ast::Alias> {
+fn __action342<
+>(
+    (_, e, _): (TextSize, ast::Alias, TextSize),
+) -> Vec<ast::Alias>
+{
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action343(
+fn __action343<
+>(
     (_, mut v, _): (TextSize, Vec<ast::Alias>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Alias, TextSize),
-) -> Vec<ast::Alias> {
+) -> Vec<ast::Alias>
+{
     {
         v.push(e);
         v
@@ -32626,59 +33281,72 @@ fn __action343(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action344(
+fn __action344<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, name, _): (TextSize, ast::Identifier, TextSize),
     (_, a, _): (TextSize, core::option::Option<ast::Identifier>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Alias {
-    ast::Alias {
-        name,
-        asname: a,
-        range: (location..end_location).into(),
-    }
+) -> ast::Alias
+{
+    ast::Alias { name, asname: a, range: (location..end_location).into() }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action345((_, __0, _): (TextSize, ast::Int, TextSize)) -> alloc::vec::Vec<ast::Int> {
+fn __action345<
+>(
+    (_, __0, _): (TextSize, ast::Int, TextSize),
+) -> alloc::vec::Vec<ast::Int>
+{
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action346(
+fn __action346<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Int>, TextSize),
     (_, e, _): (TextSize, ast::Int, TextSize),
-) -> alloc::vec::Vec<ast::Int> {
-    {
-        let mut v = v;
-        v.push(e);
-        v
-    }
+) -> alloc::vec::Vec<ast::Int>
+{
+    { let mut v = v; v.push(e); v }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action347(__lookbehind: &TextSize, __lookahead: &TextSize) -> alloc::vec::Vec<ast::Int> {
+fn __action347<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> alloc::vec::Vec<ast::Int>
+{
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action348(
+fn __action348<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Int>, TextSize),
-) -> alloc::vec::Vec<ast::Int> {
+) -> alloc::vec::Vec<ast::Int>
+{
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action349((_, e, _): (TextSize, ast::Alias, TextSize)) -> Vec<ast::Alias> {
+fn __action349<
+>(
+    (_, e, _): (TextSize, ast::Alias, TextSize),
+) -> Vec<ast::Alias>
+{
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action350(
+fn __action350<
+>(
     (_, mut v, _): (TextSize, Vec<ast::Alias>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Alias, TextSize),
-) -> Vec<ast::Alias> {
+) -> Vec<ast::Alias>
+{
     {
         v.push(e);
         v
@@ -32686,59 +33354,87 @@ fn __action350(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action351(
+fn __action351<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, name, _): (TextSize, ast::Identifier, TextSize),
     (_, a, _): (TextSize, core::option::Option<ast::Identifier>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Alias {
-    ast::Alias {
-        name,
-        asname: a,
-        range: (location..end_location).into(),
-    }
+) -> ast::Alias
+{
+    ast::Alias { name, asname: a, range: (location..end_location).into() }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action352((_, __0, _): (TextSize, ast::Expr, TextSize)) -> core::option::Option<ast::Expr> {
+fn __action352<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> core::option::Option<ast::Expr>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action353(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Expr> {
+fn __action353<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> core::option::Option<ast::Expr>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action354(
+fn __action354<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action355((_, __0, _): (TextSize, ast::Expr, TextSize)) -> core::option::Option<ast::Expr> {
+fn __action355<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> core::option::Option<ast::Expr>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action356(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Expr> {
+fn __action356<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> core::option::Option<ast::Expr>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action357((_, __0, _): (TextSize, ast::Expr, TextSize)) -> core::option::Option<ast::Expr> {
+fn __action357<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> core::option::Option<ast::Expr>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action358(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Expr> {
+fn __action358<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> core::option::Option<ast::Expr>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action359(
+fn __action359<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, body, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -32746,221 +33442,295 @@ fn __action359(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, orelse, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::IfExp(ast::ExprIfExp {
-        test: Box::new(test),
-        body: Box::new(body),
-        orelse: Box::new(orelse),
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::IfExp(
+        ast::ExprIfExp {
+            test: Box::new(test),
+            body: Box::new(body),
+            orelse: Box::new(orelse),
+            range: (location..end_location).into()
+        }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action360((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action360<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action361((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action361<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action362(__lookbehind: &TextSize, __lookahead: &TextSize) -> alloc::vec::Vec<ast::Expr> {
+fn __action362<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> alloc::vec::Vec<ast::Expr>
+{
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action363(
+fn __action363<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
-) -> alloc::vec::Vec<ast::Expr> {
+) -> alloc::vec::Vec<ast::Expr>
+{
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action364((_, __0, _): (TextSize, token::Tok, TextSize)) -> core::option::Option<token::Tok> {
+fn __action364<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> core::option::Option<token::Tok>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action365(
+fn __action365<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<token::Tok> {
+) -> core::option::Option<token::Tok>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action366(__lookbehind: &TextSize, __lookahead: &TextSize) -> alloc::vec::Vec<ast::Stmt> {
+fn __action366<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> alloc::vec::Vec<ast::Stmt>
+{
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action367(
+fn __action367<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
-) -> alloc::vec::Vec<ast::Stmt> {
+) -> alloc::vec::Vec<ast::Stmt>
+{
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action368(
+fn __action368<
+>(
     (_, __0, _): (TextSize, ast::Stmt, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action369(__lookbehind: &TextSize, __lookahead: &TextSize) -> alloc::vec::Vec<token::Tok> {
+fn __action369<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> alloc::vec::Vec<token::Tok>
+{
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action370(
+fn __action370<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<token::Tok>, TextSize),
-) -> alloc::vec::Vec<token::Tok> {
+) -> alloc::vec::Vec<token::Tok>
+{
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action371((_, __0, _): (TextSize, token::Tok, TextSize)) -> token::Tok {
+fn __action371<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> token::Tok
+{
     __0
 }
 
-fn __action372(__lookbehind: &TextSize, __lookahead: &TextSize) -> TextSize {
+fn __action372<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> TextSize
+{
     *__lookbehind
 }
 
-fn __action373(__lookbehind: &TextSize, __lookahead: &TextSize) -> TextSize {
+fn __action373<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> TextSize
+{
     *__lookahead
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action374((_, __0, _): (TextSize, token::Tok, TextSize)) -> alloc::vec::Vec<token::Tok> {
+fn __action374<
+>(
+    (_, __0, _): (TextSize, token::Tok, TextSize),
+) -> alloc::vec::Vec<token::Tok>
+{
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action375(
+fn __action375<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<token::Tok>, TextSize),
     (_, e, _): (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<token::Tok> {
-    {
-        let mut v = v;
-        v.push(e);
-        v
-    }
+) -> alloc::vec::Vec<token::Tok>
+{
+    { let mut v = v; v.push(e); v }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action376((_, __0, _): (TextSize, ast::Stmt, TextSize)) -> alloc::vec::Vec<ast::Stmt> {
+fn __action376<
+>(
+    (_, __0, _): (TextSize, ast::Stmt, TextSize),
+) -> alloc::vec::Vec<ast::Stmt>
+{
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action377(
+fn __action377<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     (_, e, _): (TextSize, ast::Stmt, TextSize),
-) -> alloc::vec::Vec<ast::Stmt> {
-    {
-        let mut v = v;
-        v.push(e);
-        v
-    }
+) -> alloc::vec::Vec<ast::Stmt>
+{
+    { let mut v = v; v.push(e); v }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action378((_, __0, _): (TextSize, ast::Expr, TextSize)) -> alloc::vec::Vec<ast::Expr> {
+fn __action378<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> alloc::vec::Vec<ast::Expr>
+{
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action379(
+fn __action379<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<ast::Expr> {
-    {
-        let mut v = v;
-        v.push(e);
-        v
-    }
+) -> alloc::vec::Vec<ast::Expr>
+{
+    { let mut v = v; v.push(e); v }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action380(
+fn __action380<
+>(
     (_, __0, _): (TextSize, ast::Identifier, TextSize),
-) -> core::option::Option<ast::Identifier> {
+) -> core::option::Option<ast::Identifier>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action381(
+fn __action381<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<ast::Identifier> {
+) -> core::option::Option<ast::Identifier>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action382(
+fn __action382<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::Identifier, TextSize),
-) -> ast::Identifier {
+) -> ast::Identifier
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action383(
+fn __action383<
+>(
     (_, __0, _): (TextSize, ast::Pattern, TextSize),
-) -> core::option::Option<ast::Pattern> {
+) -> core::option::Option<ast::Pattern>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action384(
+fn __action384<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<ast::Pattern> {
+) -> core::option::Option<ast::Pattern>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action385(__lookbehind: &TextSize, __lookahead: &TextSize) -> alloc::vec::Vec<ast::Pattern> {
+fn __action385<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> alloc::vec::Vec<ast::Pattern>
+{
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action386(
+fn __action386<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
-) -> alloc::vec::Vec<ast::Pattern> {
+) -> alloc::vec::Vec<ast::Pattern>
+{
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action387(
+fn __action387<
+>(
     (_, __0, _): (TextSize, (TextSize, ast::Expr, ast::Suite), TextSize),
-) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)> {
+) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>
+{
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action388(
-    (_, v, _): (
-        TextSize,
-        alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>,
-        TextSize,
-    ),
+fn __action388<
+>(
+    (_, v, _): (TextSize, alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>, TextSize),
     (_, e, _): (TextSize, (TextSize, ast::Expr, ast::Suite), TextSize),
-) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)> {
-    {
-        let mut v = v;
-        v.push(e);
-        v
-    }
+) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>
+{
+    { let mut v = v; v.push(e); v }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action389(
+fn __action389<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, body, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
@@ -32968,136 +33738,120 @@ fn __action389(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, orelse, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::IfExp(ast::ExprIfExp {
-        test: Box::new(test),
-        body: Box::new(body),
-        orelse: Box::new(orelse),
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::IfExp(
+        ast::ExprIfExp {
+            test: Box::new(test),
+            body: Box::new(body),
+            orelse: Box::new(orelse),
+            range: (location..end_location).into()
+        }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action390((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action390<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action391((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action391<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action392((_, __0, _): (TextSize, ast::Expr, TextSize)) -> alloc::vec::Vec<ast::Expr> {
+fn __action392<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> alloc::vec::Vec<ast::Expr>
+{
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action393(
+fn __action393<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<ast::Expr> {
-    {
-        let mut v = v;
-        v.push(e);
-        v
-    }
+) -> alloc::vec::Vec<ast::Expr>
+{
+    { let mut v = v; v.push(e); v }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action394(
+fn __action394<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Option<Box<ast::Arg>> {
+) -> Option<Box<ast::Arg>>
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action395(
+fn __action395<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, kwarg, _): (TextSize, core::option::Option<ast::Arg>, TextSize),
-) -> Option<Box<ast::Arg>> {
+) -> Option<Box<ast::Arg>>
+{
     {
         kwarg.map(Box::new)
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action396(
-    (_, __0, _): (
-        TextSize,
-        (
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        ),
-        TextSize,
-    ),
-) -> core::option::Option<(
-    Option<Box<ast::Arg>>,
-    Vec<ast::ArgWithDefault>,
-    Option<Box<ast::Arg>>,
-)> {
+fn __action396<
+>(
+    (_, __0, _): (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
+) -> core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action397(
+fn __action397<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<(
-    Option<Box<ast::Arg>>,
-    Vec<ast::ArgWithDefault>,
-    Option<Box<ast::Arg>>,
-)> {
+) -> core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action398(
+fn __action398<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
-    (_, __0, _): (
-        TextSize,
-        (
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        ),
-        TextSize,
-    ),
-) -> (
-    Option<Box<ast::Arg>>,
-    Vec<ast::ArgWithDefault>,
-    Option<Box<ast::Arg>>,
-) {
+    (_, __0, _): (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
+) -> (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action399(
+fn __action399<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, va, _): (TextSize, core::option::Option<ast::Arg>, TextSize),
     (_, kwonlyargs, _): (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-    (_, kwarg, _): (
-        TextSize,
-        core::option::Option<Option<Box<ast::Arg>>>,
-        TextSize,
-    ),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+    (_, kwarg, _): (TextSize, core::option::Option<Option<Box<ast::Arg>>>, TextSize),
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     {
         if va.is_none() && kwonlyargs.is_empty() && kwarg.is_none() {
             Err(LexicalError {
-                error: LexicalErrorType::OtherError(
-                    "named arguments must follow bare *".to_string(),
-                ),
+                error: LexicalErrorType::OtherError("named arguments must follow bare *".to_string()),
                 location,
             })?
         }
@@ -33110,120 +33864,95 @@ fn __action399(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action400(
+fn __action400<
+>(
     (_, args, _): (TextSize, Vec<ast::ArgWithDefault>, TextSize),
-) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>) {
+) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>)
+{
     {
         (vec![], args)
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action401(
+fn __action401<
+>(
     (_, posonlyargs, _): (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, args, _): (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>) {
+) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>)
+{
     {
         (posonlyargs, args)
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action402(
+fn __action402<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Option<Box<ast::Arg>> {
+) -> Option<Box<ast::Arg>>
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action403(
+fn __action403<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, kwarg, _): (TextSize, core::option::Option<ast::Arg>, TextSize),
-) -> Option<Box<ast::Arg>> {
+) -> Option<Box<ast::Arg>>
+{
     {
         kwarg.map(Box::new)
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action404(
-    (_, __0, _): (
-        TextSize,
-        (
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        ),
-        TextSize,
-    ),
-) -> core::option::Option<(
-    Option<Box<ast::Arg>>,
-    Vec<ast::ArgWithDefault>,
-    Option<Box<ast::Arg>>,
-)> {
+fn __action404<
+>(
+    (_, __0, _): (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
+) -> core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action405(
+fn __action405<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<(
-    Option<Box<ast::Arg>>,
-    Vec<ast::ArgWithDefault>,
-    Option<Box<ast::Arg>>,
-)> {
+) -> core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action406(
+fn __action406<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
-    (_, __0, _): (
-        TextSize,
-        (
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        ),
-        TextSize,
-    ),
-) -> (
-    Option<Box<ast::Arg>>,
-    Vec<ast::ArgWithDefault>,
-    Option<Box<ast::Arg>>,
-) {
+    (_, __0, _): (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
+) -> (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action407(
+fn __action407<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, va, _): (TextSize, core::option::Option<ast::Arg>, TextSize),
     (_, kwonlyargs, _): (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-    (_, kwarg, _): (
-        TextSize,
-        core::option::Option<Option<Box<ast::Arg>>>,
-        TextSize,
-    ),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+    (_, kwarg, _): (TextSize, core::option::Option<Option<Box<ast::Arg>>>, TextSize),
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     {
         if va.is_none() && kwonlyargs.is_empty() && kwarg.is_none() {
             Err(LexicalError {
-                error: LexicalErrorType::OtherError(
-                    "named arguments must follow bare *".to_string(),
-                ),
+                error: LexicalErrorType::OtherError("named arguments must follow bare *".to_string()),
                 location,
             })?
         }
@@ -33236,58 +33965,71 @@ fn __action407(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action408(
+fn __action408<
+>(
     (_, args, _): (TextSize, Vec<ast::ArgWithDefault>, TextSize),
-) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>) {
+) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>)
+{
     {
         (vec![], args)
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action409(
+fn __action409<
+>(
     (_, posonlyargs, _): (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, args, _): (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>) {
+) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>)
+{
     {
         (posonlyargs, args)
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action410(
+fn __action410<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e1, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::BinOp(ast::ExprBinOp {
-        left: Box::new(e1),
-        op: ast::Operator::BitXor,
-        right: Box::new(e2),
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::BinOp(
+        ast::ExprBinOp { left: Box::new(e1), op: ast::Operator::BitXor, right: Box::new(e2), range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action411((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action411<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action412((_, e, _): (TextSize, ast::Expr, TextSize)) -> Vec<ast::Expr> {
+fn __action412<
+>(
+    (_, e, _): (TextSize, ast::Expr, TextSize),
+) -> Vec<ast::Expr>
+{
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action413(
+fn __action413<
+>(
     (_, mut v, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> Vec<ast::Expr> {
+) -> Vec<ast::Expr>
+{
     {
         v.push(e);
         v
@@ -33295,265 +34037,239 @@ fn __action413(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action414((_, __0, _): (TextSize, ast::Expr, TextSize)) -> alloc::vec::Vec<ast::Expr> {
+fn __action414<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> alloc::vec::Vec<ast::Expr>
+{
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action415(
+fn __action415<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<ast::Expr> {
-    {
-        let mut v = v;
-        v.push(e);
-        v
-    }
+) -> alloc::vec::Vec<ast::Expr>
+{
+    { let mut v = v; v.push(e); v }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action416(
+fn __action416<
+>(
     (_, __0, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action417(
+fn __action417<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, mut values, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, last, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
         values.push(last);
-        ast::Expr::BoolOp(ast::ExprBoolOp {
-            op: ast::BoolOp::And,
-            values,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::BoolOp(
+            ast::ExprBoolOp { op: ast::BoolOp::And, values, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action418((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action418<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action419((_, __0, _): (TextSize, ast::Expr, TextSize)) -> alloc::vec::Vec<ast::Expr> {
+fn __action419<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> alloc::vec::Vec<ast::Expr>
+{
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action420(
+fn __action420<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<ast::Expr> {
-    {
-        let mut v = v;
-        v.push(e);
-        v
-    }
+) -> alloc::vec::Vec<ast::Expr>
+{
+    { let mut v = v; v.push(e); v }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action421(
-    (_, __0, _): (
-        TextSize,
-        (
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        ),
-        TextSize,
-    ),
-) -> core::option::Option<(
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-)> {
+fn __action421<
+>(
+    (_, __0, _): (TextSize, (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr), TextSize),
+) -> core::option::Option<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action422(
+fn __action422<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<(
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-)> {
+) -> core::option::Option<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action423(
+fn __action423<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> alloc::vec::Vec<(
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-)> {
+) -> alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
+{
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action424(
-    (_, v, _): (
-        TextSize,
-        alloc::vec::Vec<(
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        )>,
-        TextSize,
-    ),
-) -> alloc::vec::Vec<(
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-)> {
+fn __action424<
+>(
+    (_, v, _): (TextSize, alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
+) -> alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
+{
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action425(
-    (_, __0, _): (
-        TextSize,
-        (
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        ),
-        TextSize,
-    ),
+fn __action425<
+>(
+    (_, __0, _): (TextSize, (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr), TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> (
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-) {
+) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action426(
-    (_, __0, _): (
-        TextSize,
-        (
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        ),
-        TextSize,
-    ),
-) -> alloc::vec::Vec<(
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-)> {
+fn __action426<
+>(
+    (_, __0, _): (TextSize, (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr), TextSize),
+) -> alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
+{
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action427(
-    (_, v, _): (
-        TextSize,
-        alloc::vec::Vec<(
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        )>,
-        TextSize,
-    ),
-    (_, e, _): (
-        TextSize,
-        (
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        ),
-        TextSize,
-    ),
-) -> alloc::vec::Vec<(
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-)> {
-    {
-        let mut v = v;
-        v.push(e);
-        v
-    }
+fn __action427<
+>(
+    (_, v, _): (TextSize, alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
+    (_, e, _): (TextSize, (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr), TextSize),
+) -> alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
+{
+    { let mut v = v; v.push(e); v }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action428((_, __0, _): (TextSize, ast::Expr, TextSize)) -> alloc::vec::Vec<ast::Expr> {
+fn __action428<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> alloc::vec::Vec<ast::Expr>
+{
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action429(
+fn __action429<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<ast::Expr> {
-    {
-        let mut v = v;
-        v.push(e);
-        v
-    }
+) -> alloc::vec::Vec<ast::Expr>
+{
+    { let mut v = v; v.push(e); v }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action430(
+fn __action430<
+>(
     (_, __0, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action431(
+fn __action431<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::UnaryOp(ast::ExprUnaryOp {
-        operand: Box::new(e),
-        op: ast::UnaryOp::Not,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::UnaryOp(
+        ast::ExprUnaryOp { operand: Box::new(e), op: ast::UnaryOp::Not, range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action432((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action432<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action433(
+fn __action433<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e1, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::BinOp(ast::ExprBinOp {
-        left: Box::new(e1),
-        op: ast::Operator::BitAnd,
-        right: Box::new(e2),
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::BinOp(
+        ast::ExprBinOp { left: Box::new(e1), op: ast::Operator::BitAnd, right: Box::new(e2), range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action434((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action434<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action435((_, e, _): (TextSize, ast::ArgWithDefault, TextSize)) -> Vec<ast::ArgWithDefault> {
+fn __action435<
+>(
+    (_, e, _): (TextSize, ast::ArgWithDefault, TextSize),
+) -> Vec<ast::ArgWithDefault>
+{
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action436(
+fn __action436<
+>(
     (_, mut v, _): (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::ArgWithDefault, TextSize),
-) -> Vec<ast::ArgWithDefault> {
+) -> Vec<ast::ArgWithDefault>
+{
     {
         v.push(e);
         v
@@ -33561,54 +34277,70 @@ fn __action436(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action437(
+fn __action437<
+>(
     (_, __0, _): (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> core::option::Option<Option<Box<ast::Arg>>> {
+) -> core::option::Option<Option<Box<ast::Arg>>>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action438(
+fn __action438<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<Option<Box<ast::Arg>>> {
+) -> core::option::Option<Option<Box<ast::Arg>>>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action439(
+fn __action439<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> alloc::vec::Vec<ast::ArgWithDefault> {
+) -> alloc::vec::Vec<ast::ArgWithDefault>
+{
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action440(
+fn __action440<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> alloc::vec::Vec<ast::ArgWithDefault> {
+) -> alloc::vec::Vec<ast::ArgWithDefault>
+{
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action441(
+fn __action441<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::ArgWithDefault, TextSize),
-) -> ast::ArgWithDefault {
+) -> ast::ArgWithDefault
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action442((_, i, _): (TextSize, ast::ArgWithDefault, TextSize)) -> ast::ArgWithDefault {
+fn __action442<
+>(
+    (_, i, _): (TextSize, ast::ArgWithDefault, TextSize),
+) -> ast::ArgWithDefault
+{
     i
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action443(
+fn __action443<
+>(
     (_, mut i, _): (TextSize, ast::ArgWithDefault, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> ast::ArgWithDefault {
+) -> ast::ArgWithDefault
+{
     {
         i.default = Some(Box::new(e));
         i
@@ -33616,26 +34348,41 @@ fn __action443(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action444((_, __0, _): (TextSize, ast::Arg, TextSize)) -> core::option::Option<ast::Arg> {
+fn __action444<
+>(
+    (_, __0, _): (TextSize, ast::Arg, TextSize),
+) -> core::option::Option<ast::Arg>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action445(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Arg> {
+fn __action445<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> core::option::Option<ast::Arg>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action446((_, e, _): (TextSize, ast::ArgWithDefault, TextSize)) -> Vec<ast::ArgWithDefault> {
+fn __action446<
+>(
+    (_, e, _): (TextSize, ast::ArgWithDefault, TextSize),
+) -> Vec<ast::ArgWithDefault>
+{
     vec![e]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action447(
+fn __action447<
+>(
     (_, mut v, _): (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::ArgWithDefault, TextSize),
-) -> Vec<ast::ArgWithDefault> {
+) -> Vec<ast::ArgWithDefault>
+{
     {
         v.push(e);
         v
@@ -33643,54 +34390,70 @@ fn __action447(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action448(
+fn __action448<
+>(
     (_, __0, _): (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> core::option::Option<Option<Box<ast::Arg>>> {
+) -> core::option::Option<Option<Box<ast::Arg>>>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action449(
+fn __action449<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<Option<Box<ast::Arg>>> {
+) -> core::option::Option<Option<Box<ast::Arg>>>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action450(
+fn __action450<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> alloc::vec::Vec<ast::ArgWithDefault> {
+) -> alloc::vec::Vec<ast::ArgWithDefault>
+{
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action451(
+fn __action451<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> alloc::vec::Vec<ast::ArgWithDefault> {
+) -> alloc::vec::Vec<ast::ArgWithDefault>
+{
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action452(
+fn __action452<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::ArgWithDefault, TextSize),
-) -> ast::ArgWithDefault {
+) -> ast::ArgWithDefault
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action453((_, i, _): (TextSize, ast::ArgWithDefault, TextSize)) -> ast::ArgWithDefault {
+fn __action453<
+>(
+    (_, i, _): (TextSize, ast::ArgWithDefault, TextSize),
+) -> ast::ArgWithDefault
+{
     i
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action454(
+fn __action454<
+>(
     (_, mut i, _): (TextSize, ast::ArgWithDefault, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> ast::ArgWithDefault {
+) -> ast::ArgWithDefault
+{
     {
         i.default = Some(Box::new(e));
         i
@@ -33698,561 +34461,632 @@ fn __action454(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action455((_, __0, _): (TextSize, ast::Arg, TextSize)) -> core::option::Option<ast::Arg> {
+fn __action455<
+>(
+    (_, __0, _): (TextSize, ast::Arg, TextSize),
+) -> core::option::Option<ast::Arg>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action456(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Arg> {
+fn __action456<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> core::option::Option<ast::Arg>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action457((_, __0, _): (TextSize, ast::Arg, TextSize)) -> core::option::Option<ast::Arg> {
+fn __action457<
+>(
+    (_, __0, _): (TextSize, ast::Arg, TextSize),
+) -> core::option::Option<ast::Arg>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action458(__lookbehind: &TextSize, __lookahead: &TextSize) -> core::option::Option<ast::Arg> {
+fn __action458<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> core::option::Option<ast::Arg>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action459(
+fn __action459<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, mut values, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, last, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
         values.push(last);
-        ast::Expr::BoolOp(ast::ExprBoolOp {
-            op: ast::BoolOp::Or,
-            values,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::BoolOp(
+            ast::ExprBoolOp { op: ast::BoolOp::Or, values, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action460((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action460<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action461(
+fn __action461<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, mut values, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, last, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
         values.push(last);
-        ast::Expr::BoolOp(ast::ExprBoolOp {
-            op: ast::BoolOp::And,
-            values,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::BoolOp(
+            ast::ExprBoolOp { op: ast::BoolOp::And, values, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action462((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action462<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action463(
+fn __action463<
+>(
     (_, __0, _): (TextSize, ast::ArgWithDefault, TextSize),
-) -> alloc::vec::Vec<ast::ArgWithDefault> {
+) -> alloc::vec::Vec<ast::ArgWithDefault>
+{
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action464(
+fn __action464<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     (_, e, _): (TextSize, ast::ArgWithDefault, TextSize),
-) -> alloc::vec::Vec<ast::ArgWithDefault> {
-    {
-        let mut v = v;
-        v.push(e);
-        v
-    }
+) -> alloc::vec::Vec<ast::ArgWithDefault>
+{
+    { let mut v = v; v.push(e); v }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action465(
+fn __action465<
+>(
     (_, __0, _): (TextSize, ast::ArgWithDefault, TextSize),
-) -> alloc::vec::Vec<ast::ArgWithDefault> {
+) -> alloc::vec::Vec<ast::ArgWithDefault>
+{
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action466(
+fn __action466<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     (_, e, _): (TextSize, ast::ArgWithDefault, TextSize),
-) -> alloc::vec::Vec<ast::ArgWithDefault> {
-    {
-        let mut v = v;
-        v.push(e);
-        v
-    }
+) -> alloc::vec::Vec<ast::ArgWithDefault>
+{
+    { let mut v = v; v.push(e); v }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action467(
+fn __action467<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e1, _): (TextSize, ast::Expr, TextSize),
     (_, op, _): (TextSize, ast::Operator, TextSize),
     (_, e2, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::BinOp(ast::ExprBinOp {
-        left: Box::new(e1),
-        op,
-        right: Box::new(e2),
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::BinOp(
+        ast::ExprBinOp { left: Box::new(e1), op, right: Box::new(e2), range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action468((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action468<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action469(
+fn __action469<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, left, _): (TextSize, ast::Expr, TextSize),
     (_, comparisons, _): (TextSize, alloc::vec::Vec<(ast::CmpOp, ast::Expr)>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
         let (ops, comparators) = comparisons.into_iter().unzip();
-        ast::Expr::Compare(ast::ExprCompare {
-            left: Box::new(left),
-            ops,
-            comparators,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::Compare(
+            ast::ExprCompare { left: Box::new(left), ops, comparators, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action470((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action470<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action471(
+fn __action471<
+>(
     (_, __0, _): (TextSize, (ast::CmpOp, ast::Expr), TextSize),
-) -> alloc::vec::Vec<(ast::CmpOp, ast::Expr)> {
+) -> alloc::vec::Vec<(ast::CmpOp, ast::Expr)>
+{
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action472(
+fn __action472<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<(ast::CmpOp, ast::Expr)>, TextSize),
     (_, e, _): (TextSize, (ast::CmpOp, ast::Expr), TextSize),
-) -> alloc::vec::Vec<(ast::CmpOp, ast::Expr)> {
-    {
-        let mut v = v;
-        v.push(e);
-        v
-    }
+) -> alloc::vec::Vec<(ast::CmpOp, ast::Expr)>
+{
+    { let mut v = v; v.push(e); v }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action473(
+fn __action473<
+>(
     (_, __0, _): (TextSize, ast::CmpOp, TextSize),
     (_, __1, _): (TextSize, ast::Expr, TextSize),
-) -> (ast::CmpOp, ast::Expr) {
+) -> (ast::CmpOp, ast::Expr)
+{
     (__0, __1)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action474(
+fn __action474<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, a, _): (TextSize, ast::Expr, TextSize),
     (_, op, _): (TextSize, ast::Operator, TextSize),
     (_, b, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::BinOp(ast::ExprBinOp {
-        left: Box::new(a),
-        op,
-        right: Box::new(b),
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::BinOp(
+        ast::ExprBinOp { left: Box::new(a), op, right: Box::new(b), range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action475((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action475<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action476(
+fn __action476<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::UnaryOp(ast::ExprUnaryOp {
-        operand: Box::new(e),
-        op: ast::UnaryOp::Not,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::UnaryOp(
+        ast::ExprUnaryOp { operand: Box::new(e), op: ast::UnaryOp::Not, range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action477((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action477<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action478(
+fn __action478<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, left, _): (TextSize, ast::Expr, TextSize),
     (_, comparisons, _): (TextSize, alloc::vec::Vec<(ast::CmpOp, ast::Expr)>, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
         let (ops, comparators) = comparisons.into_iter().unzip();
-        ast::Expr::Compare(ast::ExprCompare {
-            left: Box::new(left),
-            ops,
-            comparators,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::Compare(
+            ast::ExprCompare { left: Box::new(left), ops, comparators, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action479((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action479<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action480(
+fn __action480<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, a, _): (TextSize, ast::Expr, TextSize),
     (_, op, _): (TextSize, ast::Operator, TextSize),
     (_, b, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::BinOp(ast::ExprBinOp {
-        left: Box::new(a),
-        op,
-        right: Box::new(b),
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::BinOp(
+        ast::ExprBinOp { left: Box::new(a), op, right: Box::new(b), range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action481((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action481<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action482(
+fn __action482<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, op, _): (TextSize, ast::UnaryOp, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::UnaryOp(ast::ExprUnaryOp {
-        operand: Box::new(e),
-        op,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::UnaryOp(
+        ast::ExprUnaryOp { operand: Box::new(e), op, range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action483((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action483<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action484(
+fn __action484<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e1, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::BinOp(ast::ExprBinOp {
-        left: Box::new(e1),
-        op: ast::Operator::BitOr,
-        right: Box::new(e2),
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::BinOp(
+        ast::ExprBinOp { left: Box::new(e1), op: ast::Operator::BitOr, right: Box::new(e2), range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action485((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action485<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action486(
+fn __action486<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e1, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::BinOp(ast::ExprBinOp {
-        left: Box::new(e1),
-        op: ast::Operator::BitXor,
-        right: Box::new(e2),
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::BinOp(
+        ast::ExprBinOp { left: Box::new(e1), op: ast::Operator::BitXor, right: Box::new(e2), range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action487((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action487<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action488(
+fn __action488<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, b, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::BinOp(ast::ExprBinOp {
-        left: Box::new(e),
-        op: ast::Operator::Pow,
-        right: Box::new(b),
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::BinOp(
+        ast::ExprBinOp { left: Box::new(e), op: ast::Operator::Pow, right: Box::new(b), range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action489((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action489<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action490(
+fn __action490<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, atom, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
-        ast::Expr::Await(ast::ExprAwait {
-            value: Box::new(atom),
-            range: (location..end_location).into(),
-        })
+        ast::Expr::Await(
+            ast::ExprAwait { value: Box::new(atom), range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action491((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action491<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action492(
+fn __action492<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e1, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e2, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::BinOp(ast::ExprBinOp {
-        left: Box::new(e1),
-        op: ast::Operator::BitAnd,
-        right: Box::new(e2),
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::BinOp(
+        ast::ExprBinOp { left: Box::new(e1), op: ast::Operator::BitAnd, right: Box::new(e2), range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action493((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action493<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action494(
+fn __action494<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e1, _): (TextSize, ast::Expr, TextSize),
     (_, op, _): (TextSize, ast::Operator, TextSize),
     (_, e2, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::BinOp(ast::ExprBinOp {
-        left: Box::new(e1),
-        op,
-        right: Box::new(e2),
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::BinOp(
+        ast::ExprBinOp { left: Box::new(e1), op, right: Box::new(e2), range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action495((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action495<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action496((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action496<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action497(
+fn __action497<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, f, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, a, _): (TextSize, ArgumentList, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
-        ast::Expr::Call(ast::ExprCall {
-            func: Box::new(f),
-            args: a.args,
-            keywords: a.keywords,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::Call(
+            ast::ExprCall { func: Box::new(f), args: a.args, keywords: a.keywords, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action498(
+fn __action498<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, s, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Subscript(ast::ExprSubscript {
-        value: Box::new(e),
-        slice: Box::new(s),
-        ctx: ast::ExprContext::Load,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Subscript(
+        ast::ExprSubscript { value: Box::new(e), slice: Box::new(s), ctx: ast::ExprContext::Load, range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action499(
+fn __action499<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, attr, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Attribute(ast::ExprAttribute {
-        value: Box::new(e),
-        attr,
-        ctx: ast::ExprContext::Load,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Attribute(
+        ast::ExprAttribute { value: Box::new(e), attr, ctx: ast::ExprContext::Load, range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action500(
+fn __action500<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
-    (_, s, _): (
-        TextSize,
-        alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>,
-        TextSize,
-    ),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+    (_, s, _): (TextSize, alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>, TextSize),
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     Ok(parse_strings(s)?)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action501(
+fn __action501<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, value, _): (TextSize, ast::Constant, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Constant(ast::ExprConstant {
-        value,
-        kind: None,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Constant(
+        ast::ExprConstant { value, kind: None, range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action502(
+fn __action502<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, name, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Name(ast::ExprName {
-        id: name,
-        ctx: ast::ExprContext::Load,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Name(
+        ast::ExprName { id: name, ctx: ast::ExprContext::Load, range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action503(
+fn __action503<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
         let elts = e.unwrap_or_default();
-        ast::Expr::List(ast::ExprList {
-            elts,
-            ctx: ast::ExprContext::Load,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::List(
+            ast::ExprList { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action504(
+fn __action504<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, elt, _): (TextSize, ast::Expr, TextSize),
     (_, generators, _): (TextSize, Vec<ast::Comprehension>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
-        ast::Expr::ListComp(ast::ExprListComp {
-            elt: Box::new(elt),
-            generators,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::ListComp(
+            ast::ExprListComp { elt: Box::new(elt), generators, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action505(
+fn __action505<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, elts, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, trailing_comma, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
         if elts.len() == 1 && trailing_comma.is_none() {
             elts.into_iter().next().unwrap()
         } else {
-            ast::Expr::Tuple(ast::ExprTuple {
-                elts,
-                ctx: ast::ExprContext::Load,
-                range: (location..end_location).into(),
-            })
+            ast::Expr::Tuple(
+                ast::ExprTuple { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() }
+            )
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action506(
+fn __action506<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, left, _): (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
@@ -34261,549 +35095,578 @@ fn __action506(
     (_, trailing_comma, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     {
         if left.is_none() && right.is_empty() && trailing_comma.is_none() {
             if mid.is_starred_expr() {
-                Err(LexicalError {
-                    error: LexicalErrorType::OtherError(
-                        "cannot use starred expression here".to_string(),
-                    ),
+                Err(LexicalError{
+                    error: LexicalErrorType::OtherError("cannot use starred expression here".to_string()),
                     location: mid.start(),
                 })?
             }
             Ok(mid)
         } else {
-            let elts = left
-                .into_iter()
-                .flatten()
-                .chain([mid])
-                .chain(right)
-                .collect();
-            Ok(ast::Expr::Tuple(ast::ExprTuple {
-                elts,
-                ctx: ast::ExprContext::Load,
-                range: (location..end_location).into(),
-            }))
+            let elts = left.into_iter().flatten().chain([mid]).chain(right).collect();
+            Ok(ast::Expr::Tuple(
+                ast::ExprTuple { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() },
+            ))
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action507(
+fn __action507<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Tuple(ast::ExprTuple {
-        elts: Vec::new(),
-        ctx: ast::ExprContext::Load,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Tuple(
+        ast::ExprTuple { elts: Vec::new(), ctx: ast::ExprContext::Load, range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action508(
+fn __action508<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     e
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action509(
+fn __action509<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, elt, _): (TextSize, ast::Expr, TextSize),
     (_, generators, _): (TextSize, Vec<ast::Comprehension>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
-        ast::Expr::GeneratorExp(ast::ExprGeneratorExp {
-            elt: Box::new(elt),
-            generators,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::GeneratorExp(
+            ast::ExprGeneratorExp { elt: Box::new(elt), generators, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action510(
+fn __action510<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     {
-        Err(LexicalError {
-            error: LexicalErrorType::OtherError(
-                "cannot use double starred expression here".to_string(),
-            ),
+        Err(LexicalError{
+            error : LexicalErrorType::OtherError("cannot use double starred expression here".to_string()),
             location,
-        }
-        .into())
+        }.into())
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action511(
+fn __action511<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-    (_, e, _): (
-        TextSize,
-        core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>,
-        TextSize,
-    ),
+    (_, e, _): (TextSize, core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
         let (keys, values) = e
             .unwrap_or_default()
             .into_iter()
             .map(|(k, v)| (k.map(|x| *x), v))
             .unzip();
-        ast::Expr::Dict(ast::ExprDict {
-            keys,
-            values,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::Dict(
+            ast::ExprDict { keys, values, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action512(
+fn __action512<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e1, _): (TextSize, (ast::Expr, ast::Expr), TextSize),
     (_, generators, _): (TextSize, Vec<ast::Comprehension>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
-        ast::Expr::DictComp(ast::ExprDictComp {
-            key: Box::new(e1.0),
-            value: Box::new(e1.1),
-            generators,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::DictComp(
+            ast::ExprDictComp {
+                key: Box::new(e1.0),
+                value: Box::new(e1.1),
+                generators,
+                range: (location..end_location).into()
+            }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action513(
+fn __action513<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, elts, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Set(ast::ExprSet {
-        elts,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Set(
+        ast::ExprSet { elts, range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action514(
+fn __action514<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, elt, _): (TextSize, ast::Expr, TextSize),
     (_, generators, _): (TextSize, Vec<ast::Comprehension>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
-        ast::Expr::SetComp(ast::ExprSetComp {
-            elt: Box::new(elt),
-            generators,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::SetComp(
+            ast::ExprSetComp { elt: Box::new(elt), generators, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action515(
+fn __action515<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Constant(ast::ExprConstant {
-        value: true.into(),
-        kind: None,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Constant(ast::ExprConstant { value: true.into(), kind: None, range: (location..end_location).into() })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action516(
+fn __action516<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Constant(ast::ExprConstant {
-        value: false.into(),
-        kind: None,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Constant(ast::ExprConstant { value: false.into(), kind: None, range: (location..end_location).into() })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action517(
+fn __action517<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Constant(ast::ExprConstant {
-        value: ast::Constant::None,
-        kind: None,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Constant(ast::ExprConstant { value: ast::Constant::None, kind: None, range: (location..end_location).into() })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action518(
+fn __action518<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Constant(ast::ExprConstant {
-        value: ast::Constant::Ellipsis,
-        kind: None,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Constant(ast::ExprConstant { value: ast::Constant::Ellipsis, kind: None, range: (location..end_location).into() })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action519(
+fn __action519<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, a, _): (TextSize, ast::Expr, TextSize),
     (_, op, _): (TextSize, ast::Operator, TextSize),
     (_, b, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::BinOp(ast::ExprBinOp {
-        left: Box::new(a),
-        op,
-        right: Box::new(b),
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::BinOp(
+        ast::ExprBinOp { left: Box::new(a), op, right: Box::new(b), range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action520((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action520<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action521(
+fn __action521<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, a, _): (TextSize, ast::Expr, TextSize),
     (_, op, _): (TextSize, ast::Operator, TextSize),
     (_, b, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::BinOp(ast::ExprBinOp {
-        left: Box::new(a),
-        op,
-        right: Box::new(b),
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::BinOp(
+        ast::ExprBinOp { left: Box::new(a), op, right: Box::new(b), range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action522((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action522<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action523(
+fn __action523<
+>(
     (_, __0, _): (TextSize, Vec<(Option<Box<ast::Expr>>, ast::Expr)>, TextSize),
-) -> core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>> {
+) -> core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action524(
+fn __action524<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>> {
+) -> core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action525(__lookbehind: &TextSize, __lookahead: &TextSize) -> alloc::vec::Vec<ast::Expr> {
+fn __action525<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> alloc::vec::Vec<ast::Expr>
+{
     alloc::vec![]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action526(
+fn __action526<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
-) -> alloc::vec::Vec<ast::Expr> {
+) -> alloc::vec::Vec<ast::Expr>
+{
     v
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action527(
+fn __action527<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, __0, _): (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action528(
+fn __action528<
+>(
     (_, __0, _): (TextSize, Vec<ast::Expr>, TextSize),
-) -> core::option::Option<Vec<ast::Expr>> {
+) -> core::option::Option<Vec<ast::Expr>>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action529(
+fn __action529<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<Vec<ast::Expr>> {
+) -> core::option::Option<Vec<ast::Expr>>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action530(
+fn __action530<
+>(
     (_, __0, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Expr> {
+) -> Vec<ast::Expr>
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action531(
+fn __action531<
+>(
     (_, __0, _): (TextSize, Vec<ast::Expr>, TextSize),
-) -> core::option::Option<Vec<ast::Expr>> {
+) -> core::option::Option<Vec<ast::Expr>>
+{
     Some(__0)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action532(
+fn __action532<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> core::option::Option<Vec<ast::Expr>> {
+) -> core::option::Option<Vec<ast::Expr>>
+{
     None
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action533((_, __0, _): (TextSize, ast::Expr, TextSize)) -> alloc::vec::Vec<ast::Expr> {
+fn __action533<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> alloc::vec::Vec<ast::Expr>
+{
     alloc::vec![__0]
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action534(
+fn __action534<
+>(
     (_, v, _): (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<ast::Expr> {
-    {
-        let mut v = v;
-        v.push(e);
-        v
-    }
+) -> alloc::vec::Vec<ast::Expr>
+{
+    { let mut v = v; v.push(e); v }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action535(
+fn __action535<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, op, _): (TextSize, ast::UnaryOp, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::UnaryOp(ast::ExprUnaryOp {
-        operand: Box::new(e),
-        op,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::UnaryOp(
+        ast::ExprUnaryOp { operand: Box::new(e), op, range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action536((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action536<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action537(
+fn __action537<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, b, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::BinOp(ast::ExprBinOp {
-        left: Box::new(e),
-        op: ast::Operator::Pow,
-        right: Box::new(b),
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::BinOp(
+        ast::ExprBinOp { left: Box::new(e), op: ast::Operator::Pow, right: Box::new(b), range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action538((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action538<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action539(
+fn __action539<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, atom, _): (TextSize, ast::Expr, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
-        ast::Expr::Await(ast::ExprAwait {
-            value: Box::new(atom),
-            range: (location..end_location).into(),
-        })
+        ast::Expr::Await(
+            ast::ExprAwait { value: Box::new(atom), range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action540((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action540<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action541((_, __0, _): (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action541<
+>(
+    (_, __0, _): (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     __0
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action542(
+fn __action542<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, f, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, a, _): (TextSize, ArgumentList, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
-        ast::Expr::Call(ast::ExprCall {
-            func: Box::new(f),
-            args: a.args,
-            keywords: a.keywords,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::Call(
+            ast::ExprCall { func: Box::new(f), args: a.args, keywords: a.keywords, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action543(
+fn __action543<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, s, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Subscript(ast::ExprSubscript {
-        value: Box::new(e),
-        slice: Box::new(s),
-        ctx: ast::ExprContext::Load,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Subscript(
+        ast::ExprSubscript { value: Box::new(e), slice: Box::new(s), ctx: ast::ExprContext::Load, range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action544(
+fn __action544<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, attr, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Attribute(ast::ExprAttribute {
-        value: Box::new(e),
-        attr,
-        ctx: ast::ExprContext::Load,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Attribute(
+        ast::ExprAttribute { value: Box::new(e), attr, ctx: ast::ExprContext::Load, range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action545(
+fn __action545<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
-    (_, s, _): (
-        TextSize,
-        alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>,
-        TextSize,
-    ),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+    (_, s, _): (TextSize, alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>, TextSize),
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     Ok(parse_strings(s)?)
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action546(
+fn __action546<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, value, _): (TextSize, ast::Constant, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Constant(ast::ExprConstant {
-        value,
-        kind: None,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Constant(
+        ast::ExprConstant { value, kind: None, range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action547(
+fn __action547<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, name, _): (TextSize, ast::Identifier, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Name(ast::ExprName {
-        id: name,
-        ctx: ast::ExprContext::Load,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Name(
+        ast::ExprName { id: name, ctx: ast::ExprContext::Load, range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action548(
+fn __action548<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
         let elts = e.unwrap_or_default();
-        ast::Expr::List(ast::ExprList {
-            elts,
-            ctx: ast::ExprContext::Load,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::List(
+            ast::ExprList { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action549(
+fn __action549<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, elt, _): (TextSize, ast::Expr, TextSize),
     (_, generators, _): (TextSize, Vec<ast::Comprehension>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
-        ast::Expr::ListComp(ast::ExprListComp {
-            elt: Box::new(elt),
-            generators,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::ListComp(
+            ast::ExprListComp { elt: Box::new(elt), generators, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action550(
+fn __action550<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, left, _): (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
@@ -34812,257 +35675,267 @@ fn __action550(
     (_, trailing_comma, _): (TextSize, core::option::Option<token::Tok>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     {
         if left.is_none() && right.is_empty() && trailing_comma.is_none() {
             if mid.is_starred_expr() {
-                Err(LexicalError {
-                    error: LexicalErrorType::OtherError(
-                        "cannot use starred expression here".to_string(),
-                    ),
+                Err(LexicalError{
+                    error: LexicalErrorType::OtherError("cannot use starred expression here".to_string()),
                     location: mid.start(),
                 })?
             }
             Ok(mid)
         } else {
-            let elts = left
-                .into_iter()
-                .flatten()
-                .chain([mid])
-                .chain(right)
-                .collect();
-            Ok(ast::Expr::Tuple(ast::ExprTuple {
-                elts,
-                ctx: ast::ExprContext::Load,
-                range: (location..end_location).into(),
-            }))
+            let elts = left.into_iter().flatten().chain([mid]).chain(right).collect();
+            Ok(ast::Expr::Tuple(
+                ast::ExprTuple { elts, ctx: ast::ExprContext::Load, range: (location..end_location).into() },
+            ))
         }
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action551(
+fn __action551<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Tuple(ast::ExprTuple {
-        elts: Vec::new(),
-        ctx: ast::ExprContext::Load,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Tuple(
+        ast::ExprTuple { elts: Vec::new(), ctx: ast::ExprContext::Load, range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action552(
+fn __action552<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     e
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action553(
+fn __action553<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, elt, _): (TextSize, ast::Expr, TextSize),
     (_, generators, _): (TextSize, Vec<ast::Comprehension>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
-        ast::Expr::GeneratorExp(ast::ExprGeneratorExp {
-            elt: Box::new(elt),
-            generators,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::GeneratorExp(
+            ast::ExprGeneratorExp { elt: Box::new(elt), generators, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action554(
+fn __action554<
+>(
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e, _): (TextSize, ast::Expr, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     {
-        Err(LexicalError {
-            error: LexicalErrorType::OtherError(
-                "cannot use double starred expression here".to_string(),
-            ),
+        Err(LexicalError{
+            error : LexicalErrorType::OtherError("cannot use double starred expression here".to_string()),
             location,
-        }
-        .into())
+        }.into())
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action555(
+fn __action555<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
-    (_, e, _): (
-        TextSize,
-        core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>,
-        TextSize,
-    ),
+    (_, e, _): (TextSize, core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
         let (keys, values) = e
             .unwrap_or_default()
             .into_iter()
             .map(|(k, v)| (k.map(|x| *x), v))
             .unzip();
-        ast::Expr::Dict(ast::ExprDict {
-            keys,
-            values,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::Dict(
+            ast::ExprDict { keys, values, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action556(
+fn __action556<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, e1, _): (TextSize, (ast::Expr, ast::Expr), TextSize),
     (_, generators, _): (TextSize, Vec<ast::Comprehension>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
-        ast::Expr::DictComp(ast::ExprDictComp {
-            key: Box::new(e1.0),
-            value: Box::new(e1.1),
-            generators,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::DictComp(
+            ast::ExprDictComp {
+                key: Box::new(e1.0),
+                value: Box::new(e1.1),
+                generators,
+                range: (location..end_location).into()
+            }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action557(
+fn __action557<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, elts, _): (TextSize, Vec<ast::Expr>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Set(ast::ExprSet {
-        elts,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Set(
+        ast::ExprSet { elts, range: (location..end_location).into() }
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action558(
+fn __action558<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, elt, _): (TextSize, ast::Expr, TextSize),
     (_, generators, _): (TextSize, Vec<ast::Comprehension>, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     {
-        ast::Expr::SetComp(ast::ExprSetComp {
-            elt: Box::new(elt),
-            generators,
-            range: (location..end_location).into(),
-        })
+        ast::Expr::SetComp(
+            ast::ExprSetComp { elt: Box::new(elt), generators, range: (location..end_location).into() }
+        )
     }
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action559(
+fn __action559<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Constant(ast::ExprConstant {
-        value: true.into(),
-        kind: None,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Constant(ast::ExprConstant { value: true.into(), kind: None, range: (location..end_location).into() })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action560(
+fn __action560<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Constant(ast::ExprConstant {
-        value: false.into(),
-        kind: None,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Constant(ast::ExprConstant { value: false.into(), kind: None, range: (location..end_location).into() })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action561(
+fn __action561<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Constant(ast::ExprConstant {
-        value: ast::Constant::None,
-        kind: None,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Constant(ast::ExprConstant { value: ast::Constant::None, kind: None, range: (location..end_location).into() })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action562(
+fn __action562<
+>(
     (_, location, _): (TextSize, TextSize, TextSize),
     (_, _, _): (TextSize, token::Tok, TextSize),
     (_, end_location, _): (TextSize, TextSize, TextSize),
-) -> ast::Expr {
-    ast::Expr::Constant(ast::ExprConstant {
-        value: ast::Constant::Ellipsis,
-        kind: None,
-        range: (location..end_location).into(),
-    })
+) -> ast::Expr
+{
+    ast::Expr::Constant(ast::ExprConstant { value: ast::Constant::Ellipsis, kind: None, range: (location..end_location).into() })
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action563(
+fn __action563<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Expr>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action340(__3);
+    let __temp0 = __action340(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action505(__0, __1, __2, __temp0, __4, __5)
+    __action505(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action564(
+fn __action564<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Expr>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action505(__0, __1, __2, __temp0, __3, __4)
+    __action505(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action565(
+fn __action565<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
@@ -35071,16 +35944,29 @@ fn __action565(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __5.0;
     let __end0 = __5.2;
-    let __temp0 = __action340(__5);
+    let __temp0 = __action340(
+        __5,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action506(__0, __1, __2, __3, __4, __temp0, __6, __7)
+    __action506(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action566(
+fn __action566<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
@@ -35088,16 +35974,30 @@ fn __action566(
     __4: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __4.2;
     let __end0 = __5.0;
-    let __temp0 = __action341(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action506(__0, __1, __2, __3, __4, __temp0, __5, __6)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action567(
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action506(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+        __5,
+        __6,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action567<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
@@ -35106,16 +36006,29 @@ fn __action567(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __5.0;
     let __end0 = __5.2;
-    let __temp0 = __action340(__5);
+    let __temp0 = __action340(
+        __5,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action550(__0, __1, __2, __3, __4, __temp0, __6, __7)
+    __action550(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action568(
+fn __action568<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
@@ -35123,16 +36036,30 @@ fn __action568(
     __4: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __4.2;
     let __end0 = __5.0;
-    let __temp0 = __action341(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action550(__0, __1, __2, __3, __4, __temp0, __5, __6)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action569(
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action550(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+        __5,
+        __6,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action569<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -35142,16 +36069,30 @@ fn __action569(
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __6.0;
     let __end0 = __6.2;
-    let __temp0 = __action340(__6);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action133(__0, __1, __2, __3, __4, __5, __temp0, __7, __8)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action570(
+    let __temp0 = __action340(
+        __6,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action133(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+        __7,
+        __8,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action570<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -35160,16 +36101,31 @@ fn __action570(
     __5: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __5.2;
     let __end0 = __6.0;
-    let __temp0 = __action341(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action133(__0, __1, __2, __3, __4, __5, __temp0, __6, __7)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action571(
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action133(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+        __6,
+        __7,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action571<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -35177,32 +36133,57 @@ fn __action571(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action340(__4);
+    let __temp0 = __action340(
+        __4,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action134(__0, __1, __2, __3, __temp0, __5, __6)
+    __action134(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action572(
+fn __action572<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Vec<ast::Pattern>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action134(__0, __1, __2, __3, __temp0, __4, __5)
+    __action134(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action573(
+fn __action573<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -35210,32 +36191,57 @@ fn __action573(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action340(__4);
+    let __temp0 = __action340(
+        __4,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action135(__0, __1, __2, __3, __temp0, __5, __6)
+    __action135(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action574(
+fn __action574<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action135(__0, __1, __2, __3, __temp0, __4, __5)
+    __action135(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action575(
+fn __action575<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -35245,16 +36251,30 @@ fn __action575(
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __6.0;
     let __end0 = __6.2;
-    let __temp0 = __action340(__6);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action137(__0, __1, __2, __3, __4, __5, __temp0, __7, __8)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action576(
+    let __temp0 = __action340(
+        __6,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action137(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+        __7,
+        __8,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action576<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -35263,16 +36283,31 @@ fn __action576(
     __5: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __5.2;
     let __end0 = __6.0;
-    let __temp0 = __action341(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action137(__0, __1, __2, __3, __4, __5, __temp0, __6, __7)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action577(
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action137(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+        __6,
+        __7,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action577<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -35280,32 +36315,57 @@ fn __action577(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action340(__4);
+    let __temp0 = __action340(
+        __4,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action138(__0, __1, __2, __3, __temp0, __5, __6)
+    __action138(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action578(
+fn __action578<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Vec<ast::Pattern>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action138(__0, __1, __2, __3, __temp0, __4, __5)
+    __action138(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action579(
+fn __action579<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -35313,213 +36373,371 @@ fn __action579(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action340(__4);
+    let __temp0 = __action340(
+        __4,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action139(__0, __1, __2, __3, __temp0, __5, __6)
+    __action139(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action580(
+fn __action580<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action139(__0, __1, __2, __3, __temp0, __4, __5)
+    __action139(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action581(
+fn __action581<
+>(
     __0: (TextSize, Vec<(Option<Box<ast::Expr>>, ast::Expr)>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Vec<(Option<Box<ast::Expr>>, ast::Expr)> {
+) -> Vec<(Option<Box<ast::Expr>>, ast::Expr)>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action340(__1);
+    let __temp0 = __action340(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action201(__0, __temp0)
+    __action201(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action582(
+fn __action582<
+>(
     __0: (TextSize, Vec<(Option<Box<ast::Expr>>, ast::Expr)>, TextSize),
-) -> Vec<(Option<Box<ast::Expr>>, ast::Expr)> {
+) -> Vec<(Option<Box<ast::Expr>>, ast::Expr)>
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action201(__0, __temp0)
+    __action201(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action583(
+fn __action583<
+>(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Expr> {
+) -> Vec<ast::Expr>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action340(__1);
+    let __temp0 = __action340(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action209(__0, __temp0)
+    __action209(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action584(__0: (TextSize, Vec<ast::Expr>, TextSize)) -> Vec<ast::Expr> {
+fn __action584<
+>(
+    __0: (TextSize, Vec<ast::Expr>, TextSize),
+) -> Vec<ast::Expr>
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action209(__0, __temp0)
+    __action209(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action585(
+fn __action585<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action340(__2);
+    let __temp0 = __action340(
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action237(__0, __1, __temp0, __3)
+    __action237(
+        __0,
+        __1,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action586(
+fn __action586<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action237(__0, __1, __temp0, __2)
+    __action237(
+        __0,
+        __1,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action587(
+fn __action587<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action340(__2);
+    let __temp0 = __action340(
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action234(__0, __1, __temp0, __3)
+    __action234(
+        __0,
+        __1,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action588(
+fn __action588<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action234(__0, __1, __temp0, __2)
+    __action234(
+        __0,
+        __1,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action589(
+fn __action589<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Alias>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Vec<ast::Alias> {
+) -> Vec<ast::Alias>
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action340(__3);
+    let __temp0 = __action340(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action64(__0, __1, __2, __temp0, __4, __5)
+    __action64(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action590(
+fn __action590<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Alias>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Vec<ast::Alias> {
+) -> Vec<ast::Alias>
+{
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action64(__0, __1, __2, __temp0, __3, __4)
+    __action64(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action591(
+fn __action591<
+>(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Expr> {
+) -> Vec<ast::Expr>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action340(__1);
+    let __temp0 = __action340(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action200(__0, __temp0)
+    __action200(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action592(__0: (TextSize, Vec<ast::Expr>, TextSize)) -> Vec<ast::Expr> {
+fn __action592<
+>(
+    __0: (TextSize, Vec<ast::Expr>, TextSize),
+) -> Vec<ast::Expr>
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action200(__0, __temp0)
+    __action200(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action593(
+fn __action593<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action340(__3);
+    let __temp0 = __action340(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action129(__0, __1, __2, __temp0, __4, __5)
+    __action129(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action594(
+fn __action594<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action129(__0, __1, __2, __temp0, __3, __4)
+    __action129(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action595(
+fn __action595<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -35527,32 +36745,57 @@ fn __action595(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action340(__4);
+    let __temp0 = __action340(
+        __4,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action130(__0, __1, __2, __3, __temp0, __5, __6)
+    __action130(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action596(
+fn __action596<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Identifier, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action130(__0, __1, __2, __3, __temp0, __4, __5)
+    __action130(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action597(
+fn __action597<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
@@ -35562,16 +36805,30 @@ fn __action597(
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __6.0;
     let __end0 = __6.2;
-    let __temp0 = __action340(__6);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action131(__0, __1, __2, __3, __4, __5, __temp0, __7, __8)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action598(
+    let __temp0 = __action340(
+        __6,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action131(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+        __7,
+        __8,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action598<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
@@ -35580,16 +36837,31 @@ fn __action598(
     __5: (TextSize, ast::Identifier, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __5.2;
     let __end0 = __6.0;
-    let __temp0 = __action341(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action131(__0, __1, __2, __3, __4, __5, __temp0, __6, __7)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action599(
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action131(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+        __6,
+        __7,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action599<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Expr>, TextSize),
@@ -35599,16 +36871,30 @@ fn __action599(
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, alloc::vec::Vec<ast::MatchCase>, TextSize),
     __8: (TextSize, token::Tok, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action340(__3);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action81(__0, __1, __2, __temp0, __4, __5, __6, __7, __8)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action600(
+    let __temp0 = __action340(
+        __3,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action81(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action600<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Expr>, TextSize),
@@ -35617,363 +36903,461 @@ fn __action600(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::MatchCase>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action341(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action81(__0, __1, __2, __temp0, __3, __4, __5, __6, __7)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action601(
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action81(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action601<
+>(
     __0: (TextSize, TextSize, TextSize),
-    __1: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
-    __2: (
-        TextSize,
-        core::option::Option<(
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        )>,
-        TextSize,
-    ),
+    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+    __2: (TextSize, core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action340(__3);
+    let __temp0 = __action340(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action266(__0, __1, __2, __temp0, __4)
+    __action266(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action602(
+fn __action602<
+>(
     __0: (TextSize, TextSize, TextSize),
-    __1: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
-    __2: (
-        TextSize,
-        core::option::Option<(
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        )>,
-        TextSize,
-    ),
+    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+    __2: (TextSize, core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action266(__0, __1, __2, __temp0, __3)
+    __action266(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action603(
+fn __action603<
+>(
     __0: (TextSize, TextSize, TextSize),
-    __1: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action340(__3);
+    let __temp0 = __action340(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action267(__0, __1, __2, __temp0, __4)
+    __action267(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action604(
+fn __action604<
+>(
     __0: (TextSize, TextSize, TextSize),
-    __1: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action267(__0, __1, __2, __temp0, __3)
+    __action267(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action605(
+fn __action605<
+>(
     __0: (TextSize, TextSize, TextSize),
-    __1: (
-        TextSize,
-        (
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        ),
-        TextSize,
-    ),
+    __1: (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Arguments {
+) -> ast::Arguments
+{
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action340(__2);
+    let __temp0 = __action340(
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action268(__0, __1, __temp0, __3)
+    __action268(
+        __0,
+        __1,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action606(
+fn __action606<
+>(
     __0: (TextSize, TextSize, TextSize),
-    __1: (
-        TextSize,
-        (
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        ),
-        TextSize,
-    ),
+    __1: (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Arguments {
+) -> ast::Arguments
+{
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action268(__0, __1, __temp0, __2)
+    __action268(
+        __0,
+        __1,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action607(
+fn __action607<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Arguments {
+) -> ast::Arguments
+{
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action340(__2);
+    let __temp0 = __action340(
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action269(__0, __1, __temp0, __3)
+    __action269(
+        __0,
+        __1,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action608(
+fn __action608<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Arguments {
+) -> ast::Arguments
+{
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action269(__0, __1, __temp0, __2)
+    __action269(
+        __0,
+        __1,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action609(
+fn __action609<
+>(
     __0: (TextSize, TextSize, TextSize),
-    __1: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
-    __2: (
-        TextSize,
-        core::option::Option<(
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        )>,
-        TextSize,
-    ),
+    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+    __2: (TextSize, core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action340(__3);
+    let __temp0 = __action340(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action250(__0, __1, __2, __temp0, __4)
+    __action250(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action610(
+fn __action610<
+>(
     __0: (TextSize, TextSize, TextSize),
-    __1: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
-    __2: (
-        TextSize,
-        core::option::Option<(
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        )>,
-        TextSize,
-    ),
+    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+    __2: (TextSize, core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action250(__0, __1, __2, __temp0, __3)
+    __action250(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action611(
+fn __action611<
+>(
     __0: (TextSize, TextSize, TextSize),
-    __1: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action340(__3);
+    let __temp0 = __action340(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action251(__0, __1, __2, __temp0, __4)
+    __action251(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action612(
+fn __action612<
+>(
     __0: (TextSize, TextSize, TextSize),
-    __1: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action251(__0, __1, __2, __temp0, __3)
+    __action251(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action613(
+fn __action613<
+>(
     __0: (TextSize, TextSize, TextSize),
-    __1: (
-        TextSize,
-        (
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        ),
-        TextSize,
-    ),
+    __1: (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Arguments {
+) -> ast::Arguments
+{
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action340(__2);
+    let __temp0 = __action340(
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action252(__0, __1, __temp0, __3)
+    __action252(
+        __0,
+        __1,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action614(
+fn __action614<
+>(
     __0: (TextSize, TextSize, TextSize),
-    __1: (
-        TextSize,
-        (
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        ),
-        TextSize,
-    ),
+    __1: (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Arguments {
+) -> ast::Arguments
+{
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action252(__0, __1, __temp0, __2)
+    __action252(
+        __0,
+        __1,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action615(
+fn __action615<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Arguments {
+) -> ast::Arguments
+{
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action340(__2);
+    let __temp0 = __action340(
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action253(__0, __1, __temp0, __3)
+    __action253(
+        __0,
+        __1,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action616(
+fn __action616<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Arguments {
+) -> ast::Arguments
+{
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action253(__0, __1, __temp0, __2)
+    __action253(
+        __0,
+        __1,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action617(
+fn __action617<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Vec<ast::Pattern>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action340(__2);
+    let __temp0 = __action340(
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action85(__0, __1, __temp0, __3)
+    __action85(
+        __0,
+        __1,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action618(
+fn __action618<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Vec<ast::Pattern>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action85(__0, __1, __temp0, __2)
+    __action85(
+        __0,
+        __1,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action619(
+fn __action619<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
@@ -35981,250 +37365,433 @@ fn __action619(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action340(__4);
+    let __temp0 = __action340(
+        __4,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action102(__0, __1, __2, __3, __temp0, __5, __6)
+    __action102(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action620(
+fn __action620<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     __3: (TextSize, ast::Pattern, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action102(__0, __1, __2, __3, __temp0, __4, __5)
+    __action102(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action621(
+fn __action621<
+>(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Expr> {
+) -> Vec<ast::Expr>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action340(__1);
+    let __temp0 = __action340(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action205(__0, __temp0)
+    __action205(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action622(__0: (TextSize, Vec<ast::Expr>, TextSize)) -> Vec<ast::Expr> {
+fn __action622<
+>(
+    __0: (TextSize, Vec<ast::Expr>, TextSize),
+) -> Vec<ast::Expr>
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action205(__0, __temp0)
+    __action205(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action623(
+fn __action623<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action340(__2);
+    let __temp0 = __action340(
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action196(__0, __1, __temp0, __3)
+    __action196(
+        __0,
+        __1,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action624(
+fn __action624<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action196(__0, __1, __temp0, __2)
+    __action196(
+        __0,
+        __1,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action625(
+fn __action625<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::WithItem>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action340(__2);
+    let __temp0 = __action340(
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action152(__0, __1, __temp0, __3)
+    __action152(
+        __0,
+        __1,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action626(
+fn __action626<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::WithItem>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action152(__0, __1, __temp0, __2)
+    __action152(
+        __0,
+        __1,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action627(
+fn __action627<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::WithItem>>, TextSize),
     __2: (TextSize, ast::WithItem, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action340(__4);
+    let __temp0 = __action340(
+        __4,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action153(__0, __1, __2, __3, __temp0, __5)
+    __action153(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action628(
+fn __action628<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::WithItem>>, TextSize),
     __2: (TextSize, ast::WithItem, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action341(&__start0, &__end0);
+    let __temp0 = __action341(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action153(__0, __1, __2, __3, __temp0, __4)
+    __action153(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action629(
+fn __action629<
+>(
     __0: (TextSize, ast::Suite, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __2: (TextSize, ast::Stmt, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> ast::Suite {
+) -> ast::Suite
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action364(__3);
+    let __temp0 = __action364(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action6(__0, __1, __2, __temp0, __4)
+    __action6(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action630(
+fn __action630<
+>(
     __0: (TextSize, ast::Suite, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __2: (TextSize, ast::Stmt, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Suite {
+) -> ast::Suite
+{
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action365(&__start0, &__end0);
+    let __temp0 = __action365(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action6(__0, __1, __2, __temp0, __3)
+    __action6(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action631(
+fn __action631<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt> {
+) -> Vec<ast::Stmt>
+{
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action364(__2);
+    let __temp0 = __action364(
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action10(__0, __1, __temp0, __3)
+    __action10(
+        __0,
+        __1,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action632(
+fn __action632<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt> {
+) -> Vec<ast::Stmt>
+{
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action365(&__start0, &__end0);
+    let __temp0 = __action365(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action10(__0, __1, __temp0, __2)
+    __action10(
+        __0,
+        __1,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action633(
+fn __action633<
+>(
     __0: (TextSize, Vec<ast::Stmt>, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __2: (TextSize, ast::Stmt, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt> {
+) -> Vec<ast::Stmt>
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action364(__3);
+    let __temp0 = __action364(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action13(__0, __1, __2, __temp0, __4)
+    __action13(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action634(
+fn __action634<
+>(
     __0: (TextSize, Vec<ast::Stmt>, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __2: (TextSize, ast::Stmt, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt> {
+) -> Vec<ast::Stmt>
+{
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action365(&__start0, &__end0);
+    let __temp0 = __action365(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action13(__0, __1, __2, __temp0, __3)
+    __action13(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action635(
+fn __action635<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Suite {
+) -> ast::Suite
+{
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action364(__2);
+    let __temp0 = __action364(
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action8(__0, __1, __temp0, __3)
+    __action8(
+        __0,
+        __1,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action636(
+fn __action636<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Suite {
+) -> ast::Suite
+{
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action365(&__start0, &__end0);
+    let __temp0 = __action365(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action8(__0, __1, __temp0, __2)
+    __action8(
+        __0,
+        __1,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action637(
+fn __action637<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -36234,16 +37801,30 @@ fn __action637(
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, ast::Suite, TextSize),
     __8: (TextSize, core::option::Option<ast::Suite>, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action300(__1);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action143(__0, __temp0, __2, __3, __4, __5, __6, __7, __8)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action638(
+    let __temp0 = __action300(
+        __1,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action143(
+        __0,
+        __temp0,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action638<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -36252,16 +37833,31 @@ fn __action638(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
     __7: (TextSize, core::option::Option<ast::Suite>, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action301(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action143(__0, __temp0, __1, __2, __3, __4, __5, __6, __7)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action639(
+    let __temp0 = __action301(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action143(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action639<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, TextSize, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -36271,16 +37867,30 @@ fn __action639(
     __6: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action300(__2);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action157(__0, __1, __temp0, __3, __4, __5, __6, __7, __8)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action640(
+    let __temp0 = __action300(
+        __2,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action157(
+        __0,
+        __1,
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action640<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, TextSize, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -36289,16 +37899,31 @@ fn __action640(
     __5: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action301(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action157(__0, __1, __temp0, __2, __3, __4, __5, __6, __7)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action641(
+    let __temp0 = __action301(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action157(
+        __0,
+        __1,
+        __temp0,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action641<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -36307,16 +37932,29 @@ fn __action641(
     __5: (TextSize, ast::Expr, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> ast::Comprehension {
+) -> ast::Comprehension
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action300(__1);
+    let __temp0 = __action300(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action213(__0, __temp0, __2, __3, __4, __5, __6, __7)
+    __action213(
+        __0,
+        __temp0,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action642(
+fn __action642<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -36324,60 +37962,105 @@ fn __action642(
     __4: (TextSize, ast::Expr, TextSize),
     __5: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Comprehension {
+) -> ast::Comprehension
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action301(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action213(__0, __temp0, __1, __2, __3, __4, __5, __6)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action643(
+    let __temp0 = __action301(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action213(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action643<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Vec<ast::WithItem>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action300(__1);
+    let __temp0 = __action300(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action151(__0, __temp0, __2, __3, __4, __5)
+    __action151(
+        __0,
+        __temp0,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action644(
+fn __action644<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::WithItem>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action301(&__start0, &__end0);
+    let __temp0 = __action301(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action151(__0, __temp0, __1, __2, __3, __4)
+    __action151(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action645(
+fn __action645<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ArgumentList, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> core::option::Option<(token::Tok, ArgumentList, token::Tok)> {
+) -> core::option::Option<(token::Tok, ArgumentList, token::Tok)>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action256(__0, __1, __2);
+    let __temp0 = __action256(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action254(__temp0)
+    __action254(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action646(
+fn __action646<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, TextSize, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -36387,913 +38070,1301 @@ fn __action646(
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __4.0;
     let __end0 = __6.2;
-    let __temp0 = __action645(__4, __5, __6);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action164(__0, __1, __2, __3, __temp0, __7, __8)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action647(
+    let __temp0 = __action645(
+        __4,
+        __5,
+        __6,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action164(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __7,
+        __8,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action647<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, TextSize, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Identifier, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action255(&__start0, &__end0);
+    let __temp0 = __action255(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action164(__0, __1, __2, __3, __temp0, __4, __5)
+    __action164(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action648(
+fn __action648<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> core::option::Option<Option<Box<ast::Arg>>> {
+) -> core::option::Option<Option<Box<ast::Arg>>>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action394(__0, __1);
+    let __temp0 = __action394(
+        __0,
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action448(__temp0)
+    __action448(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action649(
+fn __action649<
+>(
     __0: (TextSize, TextSize, TextSize),
-    __1: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.0;
     let __end0 = __3.2;
-    let __temp0 = __action394(__2, __3);
+    let __temp0 = __action394(
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action603(__0, __1, __temp0, __4, __5)
+    __action603(
+        __0,
+        __1,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action650(
+fn __action650<
+>(
     __0: (TextSize, TextSize, TextSize),
-    __1: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.0;
     let __end0 = __3.2;
-    let __temp0 = __action394(__2, __3);
+    let __temp0 = __action394(
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action604(__0, __1, __temp0, __4)
+    __action604(
+        __0,
+        __1,
+        __temp0,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action651(
+fn __action651<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __4.0;
     let __end0 = __5.2;
-    let __temp0 = __action648(__4, __5);
+    let __temp0 = __action648(
+        __4,
+        __5,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action399(__0, __1, __2, __3, __temp0)
+    __action399(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action652(
+fn __action652<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action449(&__start0, &__end0);
+    let __temp0 = __action449(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action399(__0, __1, __2, __3, __temp0)
+    __action399(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action653(
+fn __action653<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> core::option::Option<Option<Box<ast::Arg>>> {
+) -> core::option::Option<Option<Box<ast::Arg>>>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action402(__0, __1);
+    let __temp0 = __action402(
+        __0,
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action437(__temp0)
+    __action437(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action654(
+fn __action654<
+>(
     __0: (TextSize, TextSize, TextSize),
-    __1: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.0;
     let __end0 = __3.2;
-    let __temp0 = __action402(__2, __3);
+    let __temp0 = __action402(
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action611(__0, __1, __temp0, __4, __5)
+    __action611(
+        __0,
+        __1,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action655(
+fn __action655<
+>(
     __0: (TextSize, TextSize, TextSize),
-    __1: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+    __1: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.0;
     let __end0 = __3.2;
-    let __temp0 = __action402(__2, __3);
+    let __temp0 = __action402(
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action612(__0, __1, __temp0, __4)
+    __action612(
+        __0,
+        __1,
+        __temp0,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action656(
+fn __action656<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __4.0;
     let __end0 = __5.2;
-    let __temp0 = __action653(__4, __5);
+    let __temp0 = __action653(
+        __4,
+        __5,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action407(__0, __1, __2, __3, __temp0)
+    __action407(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action657(
+fn __action657<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action438(&__start0, &__end0);
+    let __temp0 = __action438(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action407(__0, __1, __2, __3, __temp0)
+    __action407(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action658(
+fn __action658<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::ArgWithDefault, TextSize),
-) -> alloc::vec::Vec<ast::ArgWithDefault> {
+) -> alloc::vec::Vec<ast::ArgWithDefault>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action452(__0, __1);
+    let __temp0 = __action452(
+        __0,
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action463(__temp0)
+    __action463(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action659(
+fn __action659<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::ArgWithDefault, TextSize),
-) -> alloc::vec::Vec<ast::ArgWithDefault> {
+) -> alloc::vec::Vec<ast::ArgWithDefault>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action452(__1, __2);
+    let __temp0 = __action452(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action464(__0, __temp0)
+    __action464(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action660(
+fn __action660<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>) {
+) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>)
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action450(&__start0, &__end0);
+    let __temp0 = __action450(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action401(__0, __1, __2, __temp0)
+    __action401(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action661(
+fn __action661<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>) {
+) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>)
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action451(__3);
+    let __temp0 = __action451(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action401(__0, __1, __2, __temp0)
+    __action401(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action662(
+fn __action662<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action450(&__start0, &__end0);
+    let __temp0 = __action450(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action651(__0, __1, __2, __temp0, __3, __4)
+    __action651(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action663(
+fn __action663<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action451(__3);
+    let __temp0 = __action451(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action651(__0, __1, __2, __temp0, __4, __5)
+    __action651(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action664(
+fn __action664<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action450(&__start0, &__end0);
+    let __temp0 = __action450(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action652(__0, __1, __2, __temp0)
+    __action652(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action665(
+fn __action665<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action451(__3);
+    let __temp0 = __action451(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action652(__0, __1, __2, __temp0)
+    __action652(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action666(
+fn __action666<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::ArgWithDefault, TextSize),
-) -> alloc::vec::Vec<ast::ArgWithDefault> {
+) -> alloc::vec::Vec<ast::ArgWithDefault>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action441(__0, __1);
+    let __temp0 = __action441(
+        __0,
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action465(__temp0)
+    __action465(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action667(
+fn __action667<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::ArgWithDefault, TextSize),
-) -> alloc::vec::Vec<ast::ArgWithDefault> {
+) -> alloc::vec::Vec<ast::ArgWithDefault>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action441(__1, __2);
+    let __temp0 = __action441(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action466(__0, __temp0)
+    __action466(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action668(
+fn __action668<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>) {
+) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>)
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action439(&__start0, &__end0);
+    let __temp0 = __action439(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action409(__0, __1, __2, __temp0)
+    __action409(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action669(
+fn __action669<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>) {
+) -> (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>)
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action440(__3);
+    let __temp0 = __action440(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action409(__0, __1, __2, __temp0)
+    __action409(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action670(
+fn __action670<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action439(&__start0, &__end0);
+    let __temp0 = __action439(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action656(__0, __1, __2, __temp0, __3, __4)
+    __action656(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action671(
+fn __action671<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action440(__3);
+    let __temp0 = __action440(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action656(__0, __1, __2, __temp0, __4, __5)
+    __action656(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action672(
+fn __action672<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action439(&__start0, &__end0);
+    let __temp0 = __action439(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action657(__0, __1, __2, __temp0)
+    __action657(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action673(
+fn __action673<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action440(__3);
+    let __temp0 = __action440(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action657(__0, __1, __2, __temp0)
+    __action657(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action674(
+fn __action674<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action455(__2);
+    let __temp0 = __action455(
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action662(__0, __1, __temp0, __3, __4)
+    __action662(
+        __0,
+        __1,
+        __temp0,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action675(
+fn __action675<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action456(&__start0, &__end0);
+    let __temp0 = __action456(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action662(__0, __1, __temp0, __2, __3)
+    __action662(
+        __0,
+        __1,
+        __temp0,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action676(
+fn __action676<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action455(__2);
+    let __temp0 = __action455(
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action663(__0, __1, __temp0, __3, __4, __5)
+    __action663(
+        __0,
+        __1,
+        __temp0,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action677(
+fn __action677<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action456(&__start0, &__end0);
+    let __temp0 = __action456(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action663(__0, __1, __temp0, __2, __3, __4)
+    __action663(
+        __0,
+        __1,
+        __temp0,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action678(
+fn __action678<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action455(__2);
+    let __temp0 = __action455(
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action664(__0, __1, __temp0)
+    __action664(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action679(
+fn __action679<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action456(&__start0, &__end0);
+    let __temp0 = __action456(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action664(__0, __1, __temp0)
+    __action664(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action680(
+fn __action680<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action455(__2);
+    let __temp0 = __action455(
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action665(__0, __1, __temp0, __3)
+    __action665(
+        __0,
+        __1,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action681(
+fn __action681<
+>(
     __0: (TextSize, TextSize, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action456(&__start0, &__end0);
+    let __temp0 = __action456(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action665(__0, __1, __temp0, __2)
+    __action665(
+        __0,
+        __1,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action682(
+fn __action682<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-) -> (TextSize, ast::Expr, ast::Suite) {
+) -> (TextSize, ast::Expr, ast::Suite)
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action307(__temp0, __0, __1, __2, __3)
+    __action307(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action683(
+fn __action683<
+>(
     __0: (TextSize, (String, StringKind, bool), TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> (TextSize, (String, StringKind, bool), TextSize) {
+) -> (TextSize, (String, StringKind, bool), TextSize)
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action316(__temp0, __0, __1)
+    __action316(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action684(
+fn __action684<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action108(__temp0, __0, __1, __2, __3)
+    __action108(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action685(
+fn __action685<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action433(__temp0, __0, __1, __2, __3)
+    __action433(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action686(
+fn __action686<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action492(__temp0, __0, __1, __2, __3)
+    __action492(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action687(
+fn __action687<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action417(__temp0, __0, __1, __2)
+    __action417(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action688(
+fn __action688<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action461(__temp0, __0, __1, __2)
+    __action461(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action689(
+fn __action689<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action474(__temp0, __0, __1, __2, __3)
+    __action474(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action690(
+fn __action690<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action519(__temp0, __0, __1, __2, __3)
+    __action519(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action691(
+fn __action691<
+>(
     __0: (TextSize, ast::Pattern, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Pattern, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Pattern,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action89(__temp0, __0, __1, __2, __3)
+    __action89(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action692(
+fn __action692<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action70(__temp0, __0, __1, __2, __3)
+    __action70(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action693(
-    __0: (
-        TextSize,
-        alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>,
-        TextSize,
-    ),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+fn __action693<
+>(
+    __0: (TextSize, alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>, TextSize),
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action500(__temp0, __0)
+    __action500(
+        __temp0,
+        __0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action694(
+fn __action694<
+>(
     __0: (TextSize, ast::Constant, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action501(__temp0, __0, __1)
+    __action501(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action695(
+fn __action695<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action502(__temp0, __0, __1)
+    __action502(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action696(
+fn __action696<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action503(__temp0, __0, __1, __2, __3)
+    __action503(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action697(
+fn __action697<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action504(__temp0, __0, __1, __2, __3, __4)
+    __action504(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action698(
+fn __action698<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action563(__temp0, __0, __1, __2, __3, __4)
+    __action563(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action699(
+fn __action699<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action564(__temp0, __0, __1, __2, __3)
+    __action564(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action700(
+fn __action700<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -37301,253 +39372,437 @@ fn __action700(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action565(__temp0, __0, __1, __2, __3, __4, __5, __6)
+    __action565(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action701(
+fn __action701<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action566(__temp0, __0, __1, __2, __3, __4, __5)
+    __action566(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action702(
+fn __action702<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action507(__temp0, __0, __1, __2)
+    __action507(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action703(
+fn __action703<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action509(__temp0, __0, __1, __2, __3, __4)
+    __action509(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action704(
+fn __action704<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action510(__0, __temp0, __1, __2, __3, __4)
+    __action510(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action705(
+fn __action705<
+>(
     __0: (TextSize, token::Tok, TextSize),
-    __1: (
-        TextSize,
-        core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>,
-        TextSize,
-    ),
+    __1: (TextSize, core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action511(__temp0, __0, __1, __2, __3)
+    __action511(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action706(
+fn __action706<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, (ast::Expr, ast::Expr), TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action512(__temp0, __0, __1, __2, __3, __4)
+    __action512(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action707(
+fn __action707<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action513(__temp0, __0, __1, __2, __3)
+    __action513(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action708(
+fn __action708<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action514(__temp0, __0, __1, __2, __3, __4)
+    __action514(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action709(
+fn __action709<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action515(__temp0, __0, __1)
+    __action515(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action710(
+fn __action710<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action516(__temp0, __0, __1)
+    __action516(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action711(
+fn __action711<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action517(__temp0, __0, __1)
+    __action517(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action712(
+fn __action712<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action518(__temp0, __0, __1)
+    __action518(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action713(
-    __0: (
-        TextSize,
-        alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>,
-        TextSize,
-    ),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+fn __action713<
+>(
+    __0: (TextSize, alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>, TextSize),
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action545(__temp0, __0)
+    __action545(
+        __temp0,
+        __0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action714(
+fn __action714<
+>(
     __0: (TextSize, ast::Constant, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action546(__temp0, __0, __1)
+    __action546(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action715(
+fn __action715<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action547(__temp0, __0, __1)
+    __action547(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action716(
+fn __action716<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action548(__temp0, __0, __1, __2, __3)
+    __action548(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action717(
+fn __action717<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action549(__temp0, __0, __1, __2, __3, __4)
+    __action549(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action718(
+fn __action718<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -37555,311 +39810,549 @@ fn __action718(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action567(__temp0, __0, __1, __2, __3, __4, __5, __6)
+    __action567(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action719(
+fn __action719<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action568(__temp0, __0, __1, __2, __3, __4, __5)
+    __action568(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action720(
+fn __action720<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action551(__temp0, __0, __1, __2)
+    __action551(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action721(
+fn __action721<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action553(__temp0, __0, __1, __2, __3, __4)
+    __action553(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action722(
+fn __action722<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action554(__0, __temp0, __1, __2, __3, __4)
+    __action554(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action723(
+fn __action723<
+>(
     __0: (TextSize, token::Tok, TextSize),
-    __1: (
-        TextSize,
-        core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>,
-        TextSize,
-    ),
+    __1: (TextSize, core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action555(__temp0, __0, __1, __2, __3)
+    __action555(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action724(
+fn __action724<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, (ast::Expr, ast::Expr), TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action556(__temp0, __0, __1, __2, __3, __4)
+    __action556(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action725(
+fn __action725<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action557(__temp0, __0, __1, __2, __3)
+    __action557(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action726(
+fn __action726<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action558(__temp0, __0, __1, __2, __3, __4)
+    __action558(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action727(
+fn __action727<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action559(__temp0, __0, __1)
+    __action559(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action728(
+fn __action728<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action560(__temp0, __0, __1)
+    __action560(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action729(
+fn __action729<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action561(__temp0, __0, __1)
+    __action561(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action730(
+fn __action730<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action562(__temp0, __0, __1)
+    __action562(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action731(
+fn __action731<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ArgumentList, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action497(__temp0, __0, __1, __2, __3, __4)
+    __action497(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action732(
+fn __action732<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action498(__temp0, __0, __1, __2, __3, __4)
+    __action498(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action733(
+fn __action733<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action499(__temp0, __0, __1, __2, __3)
+    __action499(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action734(
+fn __action734<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ArgumentList, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action542(__temp0, __0, __1, __2, __3, __4)
+    __action542(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action735(
+fn __action735<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action543(__temp0, __0, __1, __2, __3, __4)
+    __action543(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action736(
+fn __action736<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action544(__temp0, __0, __1, __2, __3)
+    __action544(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action737(
+fn __action737<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action490(__temp0, __0, __1, __2)
+    __action490(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action738(
+fn __action738<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action539(__temp0, __0, __1, __2)
+    __action539(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action739(
+fn __action739<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action115(__temp0, __0, __1)
+    __action115(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action740(
+fn __action740<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
@@ -37868,31 +40361,58 @@ fn __action740(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action373(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action646(__0, __temp0, __1, __2, __3, __4, __5, __6, __7)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action741(
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action646(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action741<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action647(__0, __temp0, __1, __2, __3, __4)
+    __action647(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action742(
+fn __action742<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
@@ -37901,16 +40421,31 @@ fn __action742(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action569(__temp0, __0, __1, __2, __3, __4, __5, __6, __7)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action743(
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action569(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action743<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
@@ -37918,92 +40453,167 @@ fn __action743(
     __4: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action570(__temp0, __0, __1, __2, __3, __4, __5, __6)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action744(
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action570(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action744<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action571(__temp0, __0, __1, __2, __3, __4, __5)
+    __action571(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action745(
+fn __action745<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action572(__temp0, __0, __1, __2, __3, __4)
+    __action572(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action746(
+fn __action746<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action573(__temp0, __0, __1, __2, __3, __4, __5)
+    __action573(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action747(
+fn __action747<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action574(__temp0, __0, __1, __2, __3, __4)
+    __action574(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action748(
+fn __action748<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action136(__temp0, __0, __1, __2, __3)
+    __action136(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action749(
+fn __action749<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
@@ -38012,16 +40622,31 @@ fn __action749(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action575(__temp0, __0, __1, __2, __3, __4, __5, __6, __7)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action750(
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action575(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action750<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
@@ -38029,385 +40654,687 @@ fn __action750(
     __4: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action576(__temp0, __0, __1, __2, __3, __4, __5, __6)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action751(
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action576(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action751<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action577(__temp0, __0, __1, __2, __3, __4, __5)
+    __action577(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action752(
+fn __action752<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action578(__temp0, __0, __1, __2, __3, __4)
+    __action578(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action753(
+fn __action753<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action579(__temp0, __0, __1, __2, __3, __4, __5)
+    __action579(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action754(
+fn __action754<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action580(__temp0, __0, __1, __2, __3, __4)
+    __action580(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action755(
+fn __action755<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action140(__temp0, __0, __1, __2, __3)
+    __action140(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action756(
+fn __action756<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, alloc::vec::Vec<(ast::CmpOp, ast::Expr)>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action469(__temp0, __0, __1, __2)
+    __action469(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action757(
+fn __action757<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, alloc::vec::Vec<(ast::CmpOp, ast::Expr)>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action478(__temp0, __0, __1, __2)
+    __action478(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action758(
+fn __action758<
+>(
     __0: (TextSize, ast::Constant, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action105(__temp0, __0, __1)
+    __action105(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action759(
+fn __action759<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action107(__temp0, __0, __1, __2)
+    __action107(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action760(
+fn __action760<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action165(__temp0, __0, __1, __2)
+    __action165(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action761(
+fn __action761<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action23(__temp0, __0, __1, __2)
+    __action23(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action762(
+fn __action762<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Arg {
+) -> ast::Arg
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action163(__temp0, __0, __1, __2)
+    __action163(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action763(
+fn __action763<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler {
+) -> ast::ExceptHandler
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action149(__temp0, __0, __1, __2, __3)
+    __action149(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action764(
+fn __action764<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, (ast::Expr, ast::Identifier), TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler {
+) -> ast::ExceptHandler
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action150(__temp0, __0, __1, __2, __3)
+    __action150(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action765(
+fn __action765<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler {
+) -> ast::ExceptHandler
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action147(__temp0, __0, __1, __2, __3, __4)
+    __action147(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action766(
+fn __action766<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, (ast::Expr, ast::Identifier), TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler {
+) -> ast::ExceptHandler
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action148(__temp0, __0, __1, __2, __3, __4)
+    __action148(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action767(
+fn __action767<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action238(__temp0, __0, __1, __2, __3)
+    __action238(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action768(
+fn __action768<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action484(__temp0, __0, __1, __2, __3)
+    __action484(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action769(
+fn __action769<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action24(__temp0, __0, __1, __2)
+    __action24(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action770(
+fn __action770<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action25(__temp0, __0, __1, __2, __3)
+    __action25(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action771(
+fn __action771<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action26(__temp0, __0, __1, __2, __3, __4)
+    __action26(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action772(
+fn __action772<
+>(
     __0: (TextSize, ast::UnaryOp, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action482(__temp0, __0, __1, __2)
+    __action482(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action773(
+fn __action773<
+>(
     __0: (TextSize, ast::UnaryOp, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action535(__temp0, __0, __1, __2)
+    __action535(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action774(
+fn __action774<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action50(__temp0, __0, __1)
+    __action50(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action775(
+fn __action775<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action51(__temp0, __0, __1)
+    __action51(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action776(
+fn __action776<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action52(__temp0, __0, __1, __2)
+    __action52(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action777(
+fn __action777<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action53(__temp0, __0, __1)
+    __action53(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action778(
+fn __action778<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -38416,16 +41343,31 @@ fn __action778(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
     __7: (TextSize, core::option::Option<ast::Suite>, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action637(__temp0, __0, __1, __2, __3, __4, __5, __6, __7)
+    __action637(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action779(
+fn __action779<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -38433,16 +41375,30 @@ fn __action779(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Suite, TextSize),
     __6: (TextSize, core::option::Option<ast::Suite>, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action638(__temp0, __0, __1, __2, __3, __4, __5, __6)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action780(
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action638(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action780<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -38451,16 +41407,31 @@ fn __action780(
     __5: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action373(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action639(__0, __temp0, __1, __2, __3, __4, __5, __6, __7)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action781(
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action639(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action781<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
@@ -38468,494 +41439,820 @@ fn __action781(
     __4: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action373(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action640(__0, __temp0, __1, __2, __3, __4, __5, __6)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action782(
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action640(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action782<
+>(
     __0: (TextSize, ast::Expr, TextSize),
-    __1: (
-        TextSize,
-        core::option::Option<Vec<ast::Comprehension>>,
-        TextSize,
-    ),
+    __1: (TextSize, core::option::Option<Vec<ast::Comprehension>>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> (
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-) {
+) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action217(__temp0, __0, __1, __2)
+    __action217(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action783(
+fn __action783<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> (
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-) {
+) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action218(__temp0, __0, __1, __2, __3)
+    __action218(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action784(
+fn __action784<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> (
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-) {
+) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action219(__temp0, __0, __1, __2)
+    __action219(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action785(
+fn __action785<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> (
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-) {
+) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action220(__temp0, __0, __1, __2)
+    __action220(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action786(
+fn __action786<
+>(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action585(__temp0, __0, __1, __2)
+    __action585(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action787(
+fn __action787<
+>(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action586(__temp0, __0, __1)
+    __action586(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action788(
+fn __action788<
+>(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action587(__temp0, __0, __1, __2)
+    __action587(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action789(
+fn __action789<
+>(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action588(__temp0, __0, __1)
+    __action588(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action790(
+fn __action790<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Identifier>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action68(__temp0, __0, __1, __2)
+    __action68(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action791(
+fn __action791<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-    __4: (
-        TextSize,
-        alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>,
-        TextSize,
-    ),
+    __4: (TextSize, alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>, TextSize),
     __5: (TextSize, core::option::Option<ast::Suite>, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action141(__temp0, __0, __1, __2, __3, __4, __5)
+    __action141(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action792(
+fn __action792<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, core::option::Option<ast::Identifier>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Alias {
+) -> ast::Alias
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action351(__temp0, __0, __1, __2)
+    __action351(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action793(
+fn __action793<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, core::option::Option<ast::Identifier>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Alias {
+) -> ast::Alias
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action344(__temp0, __0, __1, __2)
+    __action344(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action794(
+fn __action794<
+>(
     __0: (TextSize, Vec<ast::Alias>, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> Vec<ast::Alias> {
+) -> Vec<ast::Alias>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action63(__temp0, __0, __1)
+    __action63(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action795(
+fn __action795<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Alias>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Vec<ast::Alias> {
+) -> Vec<ast::Alias>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action589(__temp0, __0, __1, __2, __3, __4)
+    __action589(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action796(
+fn __action796<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Alias>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Vec<ast::Alias> {
+) -> Vec<ast::Alias>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action590(__temp0, __0, __1, __2, __3)
+    __action590(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action797(
+fn __action797<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> Vec<ast::Alias> {
+) -> Vec<ast::Alias>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action65(__temp0, __0, __1)
+    __action65(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action798(
+fn __action798<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Alias>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action57(__temp0, __0, __1, __2)
+    __action57(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action799(
+fn __action799<
+>(
     __0: (TextSize, token::Tok, TextSize),
-    __1: (
-        TextSize,
-        (Option<ast::Int>, Option<ast::Identifier>),
-        TextSize,
-    ),
+    __1: (TextSize, (Option<ast::Int>, Option<ast::Identifier>), TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Vec<ast::Alias>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action58(__temp0, __0, __1, __2, __3, __4)
+    __action58(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action800(
+fn __action800<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Arguments>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action171(__temp0, __0, __1, __2, __3, __4)
+    __action171(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action801(
+fn __action801<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action109(__temp0, __0, __1)
+    __action109(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action802(
+fn __action802<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action110(__temp0, __0, __1)
+    __action110(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action803(
+fn __action803<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action111(__temp0, __0, __1)
+    __action111(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action804(
+fn __action804<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action112(__temp0, __0, __1)
+    __action112(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action805(
+fn __action805<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action113(__temp0, __0, __1)
+    __action113(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action806(
-    __0: (
-        TextSize,
-        alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>,
-        TextSize,
-    ),
+fn __action806<
+>(
+    __0: (TextSize, alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> Result<ast::Pattern, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Pattern,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action114(__temp0, __0, __1)
+    __action114(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action807(
+fn __action807<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action123(__temp0, __0, __1)
+    __action123(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action808(
+fn __action808<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action124(__temp0, __0, __1)
+    __action124(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action809(
+fn __action809<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action125(__temp0, __0, __1)
+    __action125(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action810(
-    __0: (
-        TextSize,
-        alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>,
-        TextSize,
-    ),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+fn __action810<
+>(
+    __0: (TextSize, alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>, TextSize),
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action126(__temp0, __0)
+    __action126(
+        __temp0,
+        __0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action811(
+fn __action811<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action128(__temp0, __0, __1, __2)
+    __action128(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action812(
+fn __action812<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action593(__temp0, __0, __1, __2, __3, __4)
+    __action593(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action813(
+fn __action813<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action594(__temp0, __0, __1, __2, __3)
+    __action594(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action814(
+fn __action814<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action595(__temp0, __0, __1, __2, __3, __4, __5)
+    __action595(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action815(
+fn __action815<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action596(__temp0, __0, __1, __2, __3, __4)
+    __action596(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action816(
+fn __action816<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -38964,16 +42261,31 @@ fn __action816(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action597(__temp0, __0, __1, __2, __3, __4, __5, __6, __7)
+    __action597(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action817(
+fn __action817<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -38981,71 +42293,128 @@ fn __action817(
     __4: (TextSize, ast::Identifier, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action598(__temp0, __0, __1, __2, __3, __4, __5, __6)
+    __action598(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action818(
+fn __action818<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Pattern, TextSize),
     __2: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Suite, TextSize),
-) -> ast::MatchCase {
+) -> ast::MatchCase
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action82(__temp0, __0, __1, __2, __3, __4)
+    __action82(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action819(
+fn __action819<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action116(__temp0, __0, __1)
+    __action116(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action820(
+fn __action820<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action117(__temp0, __0, __1, __2, __3)
+    __action117(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action821(
+fn __action821<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action118(__temp0, __0, __1, __2, __3)
+    __action118(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action822(
+fn __action822<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -39053,16 +42422,30 @@ fn __action822(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, alloc::vec::Vec<ast::MatchCase>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action79(__temp0, __0, __1, __2, __3, __4, __5, __6)
+    __action79(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action823(
+fn __action823<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -39071,16 +42454,31 @@ fn __action823(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::MatchCase>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action80(__temp0, __0, __1, __2, __3, __4, __5, __6, __7)
+    __action80(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action824(
+fn __action824<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -39089,16 +42487,31 @@ fn __action824(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::MatchCase>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action599(__temp0, __0, __1, __2, __3, __4, __5, __6, __7)
+    __action599(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action825(
+fn __action825<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -39106,890 +42519,1262 @@ fn __action825(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, alloc::vec::Vec<ast::MatchCase>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action600(__temp0, __0, __1, __2, __3, __4, __5, __6)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action826(
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action600(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action826<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action170(__temp0, __0, __1, __2, __3)
+    __action170(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action827(
+fn __action827<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Identifier>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action69(__temp0, __0, __1, __2)
+    __action69(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action828(
+fn __action828<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action431(__temp0, __0, __1, __2)
+    __action431(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action829(
+fn __action829<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action476(__temp0, __0, __1, __2)
+    __action476(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action830(
+fn __action830<
+>(
     __0: (TextSize, Vec<ast::Pattern>, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action91(__temp0, __0, __1)
+    __action91(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action831(
+fn __action831<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action230(__temp0, __0, __1, __2)
+    __action230(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action832(
+fn __action832<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action459(__temp0, __0, __1, __2)
+    __action459(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action833(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
-    __1: (
-        TextSize,
-        core::option::Option<(
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        )>,
-        TextSize,
-    ),
+fn __action833<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+    __1: (TextSize, core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action601(__temp0, __0, __1, __2, __3)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action834(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
-    __1: (
-        TextSize,
-        core::option::Option<(
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        )>,
-        TextSize,
-    ),
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action601(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action834<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+    __1: (TextSize, core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action602(__temp0, __0, __1, __2)
+    __action602(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action835(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action835<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action649(__temp0, __0, __1, __2, __3, __4)
+    __action649(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action836(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action836<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action650(__temp0, __0, __1, __2, __3)
+    __action650(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action837(
-    __0: (
-        TextSize,
-        (
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        ),
-        TextSize,
-    ),
+fn __action837<
+>(
+    __0: (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Arguments {
+) -> ast::Arguments
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action605(__temp0, __0, __1, __2)
+    __action605(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action838(
-    __0: (
-        TextSize,
-        (
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        ),
-        TextSize,
-    ),
+fn __action838<
+>(
+    __0: (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Arguments {
+) -> ast::Arguments
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action606(__temp0, __0, __1)
+    __action606(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action839(
+fn __action839<
+>(
     __0: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Arguments {
+) -> ast::Arguments
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action607(__temp0, __0, __1, __2)
+    __action607(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action840(
+fn __action840<
+>(
     __0: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Arguments {
+) -> ast::Arguments
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action608(__temp0, __0, __1)
+    __action608(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action841(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
-    __1: (
-        TextSize,
-        core::option::Option<(
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        )>,
-        TextSize,
-    ),
+fn __action841<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+    __1: (TextSize, core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action609(__temp0, __0, __1, __2, __3)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action842(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
-    __1: (
-        TextSize,
-        core::option::Option<(
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        )>,
-        TextSize,
-    ),
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action609(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action842<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+    __1: (TextSize, core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action610(__temp0, __0, __1, __2)
+    __action610(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action843(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action843<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action654(__temp0, __0, __1, __2, __3, __4)
+    __action654(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action844(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action844<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action655(__temp0, __0, __1, __2, __3)
+    __action655(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action845(
-    __0: (
-        TextSize,
-        (
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        ),
-        TextSize,
-    ),
+fn __action845<
+>(
+    __0: (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Arguments {
+) -> ast::Arguments
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action613(__temp0, __0, __1, __2)
+    __action613(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action846(
-    __0: (
-        TextSize,
-        (
-            Option<Box<ast::Arg>>,
-            Vec<ast::ArgWithDefault>,
-            Option<Box<ast::Arg>>,
-        ),
-        TextSize,
-    ),
+fn __action846<
+>(
+    __0: (TextSize, (Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>), TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Arguments {
+) -> ast::Arguments
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action614(__temp0, __0, __1)
+    __action614(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action847(
+fn __action847<
+>(
     __0: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Arguments {
+) -> ast::Arguments
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action615(__temp0, __0, __1, __2)
+    __action615(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action848(
+fn __action848<
+>(
     __0: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Arguments {
+) -> ast::Arguments
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action616(__temp0, __0, __1)
+    __action616(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action849(
+fn __action849<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action674(__temp0, __0, __1, __2, __3)
+    __action674(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action850(
+fn __action850<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action675(__temp0, __0, __1, __2)
+    __action675(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action851(
+fn __action851<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action676(__temp0, __0, __1, __2, __3, __4)
+    __action676(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action852(
+fn __action852<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action677(__temp0, __0, __1, __2, __3)
+    __action677(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action853(
+fn __action853<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action678(__temp0, __0, __1)
+    __action678(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action854(
+fn __action854<
+>(
     __0: (TextSize, token::Tok, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action679(__temp0, __0)
+    __action679(
+        __temp0,
+        __0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action855(
+fn __action855<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action680(__temp0, __0, __1, __2)
+    __action680(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action856(
+fn __action856<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action681(__temp0, __0, __1)
+    __action681(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action857(
+fn __action857<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action670(__temp0, __0, __1, __2, __3)
+    __action670(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action858(
+fn __action858<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action671(__temp0, __0, __1, __2, __3, __4)
+    __action671(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action859(
+fn __action859<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Arg>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action672(__temp0, __0, __1)
+    __action672(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action860(
+fn __action860<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Arg>, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action673(__temp0, __0, __1, __2)
+    __action673(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action861(
+fn __action861<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Arguments>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action158(__temp0, __0, __1, __2, __3)
+    __action158(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action862(
+fn __action862<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action22(__temp0, __0, __1)
+    __action22(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action863(
+fn __action863<
+>(
     __0: (TextSize, ast::Pattern, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action84(__temp0, __0, __1, __2)
+    __action84(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action864(
+fn __action864<
+>(
     __0: (TextSize, Vec<ast::Pattern>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action617(__temp0, __0, __1, __2)
+    __action617(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action865(
+fn __action865<
+>(
     __0: (TextSize, Vec<ast::Pattern>, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action618(__temp0, __0, __1)
+    __action618(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action866(
+fn __action866<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action488(__temp0, __0, __1, __2, __3)
+    __action488(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action867(
+fn __action867<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action537(__temp0, __0, __1, __2, __3)
+    __action537(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action868(
+fn __action868<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action55(__temp0, __0, __1)
+    __action55(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action869(
+fn __action869<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action56(__temp0, __0, __1, __2, __3)
+    __action56(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action870(
+fn __action870<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Pattern, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action99(__temp0, __0, __1, __2, __3)
+    __action99(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action871(
+fn __action871<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action100(__temp0, __0, __1, __2)
+    __action100(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action872(
+fn __action872<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Pattern, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action101(__temp0, __0, __1, __2, __3, __4)
+    __action101(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action873(
+fn __action873<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     __2: (TextSize, ast::Pattern, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action619(__temp0, __0, __1, __2, __3, __4, __5)
+    __action619(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action874(
+fn __action874<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     __2: (TextSize, ast::Pattern, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action620(__temp0, __0, __1, __2, __3, __4)
+    __action620(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action875(
+fn __action875<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Pattern>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action103(__temp0, __0, __1, __2, __3)
+    __action103(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action876(
+fn __action876<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action467(__temp0, __0, __1, __2, __3)
+    __action467(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action877(
+fn __action877<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action494(__temp0, __0, __1, __2, __3)
+    __action494(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action878(
+fn __action878<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -39997,260 +43782,464 @@ fn __action878(
     __4: (TextSize, ast::Expr, TextSize),
     __5: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Comprehension {
+) -> ast::Comprehension
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action641(__temp0, __0, __1, __2, __3, __4, __5, __6)
+    __action641(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action879(
+fn __action879<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Comprehension {
+) -> ast::Comprehension
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action642(__temp0, __0, __1, __2, __3, __4, __5)
+    __action642(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action880(
+fn __action880<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Expr>, TextSize),
-) -> Option<ast::Expr> {
+) -> Option<ast::Expr>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action199(__temp0, __0, __1)
+    __action199(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action881(
+fn __action881<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action211(__temp0, __0, __1, __2)
+    __action211(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action882(
+fn __action882<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Identifier, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action104(__temp0, __0, __1, __2)
+    __action104(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action883(
+fn __action883<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Arg {
+) -> ast::Arg
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action162(__temp0, __0, __1, __2)
+    __action162(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action884(
+fn __action884<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Arg {
+) -> ast::Arg
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action160(__temp0, __0, __1)
+    __action160(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action885(
+fn __action885<
+>(
     __0: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __3: (TextSize, core::option::Option<Option<ast::Expr>>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action198(__temp0, __0, __1, __2, __3, __4)
+    __action198(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action886(
+fn __action886<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action194(__temp0, __0, __1)
+    __action194(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action887(
+fn __action887<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action195(__temp0, __0, __1, __2)
+    __action195(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action888(
+fn __action888<
+>(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action623(__temp0, __0, __1, __2)
+    __action623(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action889(
+fn __action889<
+>(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action624(__temp0, __0, __1)
+    __action624(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action890(
+fn __action890<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action480(__temp0, __0, __1, __2, __3)
+    __action480(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action891(
+fn __action891<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action521(__temp0, __0, __1, __2, __3)
+    __action521(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action892(
+fn __action892<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Expr, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action359(__temp0, __0, __1, __2, __3, __4, __5)
+    __action359(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action893(
+fn __action893<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Expr, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action389(__temp0, __0, __1, __2, __3, __4, __5)
+    __action389(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action894(
+fn __action894<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Suite, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Mod {
+) -> ast::Mod
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1(__temp0, __0, __1, __2)
+    __action1(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action895(
+fn __action895<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Suite, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Mod {
+) -> ast::Mod
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action2(__temp0, __0, __1, __2)
+    __action2(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action896(
+fn __action896<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<token::Tok>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Mod {
+) -> ast::Mod
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action3(__temp0, __0, __1, __2, __3)
+    __action3(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action897(
+fn __action897<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -40258,16 +44247,30 @@ fn __action897(
     __4: (TextSize, core::option::Option<ast::Suite>, TextSize),
     __5: (TextSize, core::option::Option<ast::Suite>, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action144(__temp0, __0, __1, __2, __3, __4, __5, __6)
+    __action144(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action898(
+fn __action898<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -40275,443 +44278,671 @@ fn __action898(
     __4: (TextSize, core::option::Option<ast::Suite>, TextSize),
     __5: (TextSize, core::option::Option<ast::Suite>, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action145(__temp0, __0, __1, __2, __3, __4, __5, __6)
+    __action145(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action899(
+fn __action899<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action146(__temp0, __0, __1, __2, __3)
+    __action146(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action900(
+fn __action900<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::ArgWithDefault {
+) -> ast::ArgWithDefault
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action161(__temp0, __0, __1, __2)
+    __action161(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action901(
+fn __action901<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::ArgWithDefault {
+) -> ast::ArgWithDefault
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action159(__temp0, __0, __1)
+    __action159(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action902(
+fn __action902<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action119(__temp0, __0, __1)
+    __action119(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action903(
+fn __action903<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
     __4: (TextSize, core::option::Option<ast::Suite>, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action142(__temp0, __0, __1, __2, __3, __4)
+    __action142(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action904(
+fn __action904<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::WithItem {
+) -> ast::WithItem
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action284(__temp0, __0, __1)
+    __action284(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action905(
+fn __action905<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::WithItem {
+) -> ast::WithItem
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action285(__temp0, __0, __1, __2, __3)
+    __action285(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action906(
+fn __action906<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::WithItem {
+) -> ast::WithItem
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action286(__temp0, __0, __1, __2, __3)
+    __action286(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action907(
+fn __action907<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::WithItem {
+) -> ast::WithItem
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action279(__temp0, __0, __1)
+    __action279(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action908(
+fn __action908<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::WithItem {
+) -> ast::WithItem
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action280(__temp0, __0, __1, __2, __3)
+    __action280(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action909(
+fn __action909<
+>(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action156(__temp0, __0, __1)
+    __action156(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action910(
+fn __action910<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::WithItem>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action643(__temp0, __0, __1, __2, __3, __4)
+    __action643(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action911(
+fn __action911<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::WithItem>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action644(__temp0, __0, __1, __2, __3)
+    __action644(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action912(
+fn __action912<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action410(__temp0, __0, __1, __2, __3)
+    __action410(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action913(
+fn __action913<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action486(__temp0, __0, __1, __2, __3)
+    __action486(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action914(
+fn __action914<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action166(__temp0, __0, __1, __2)
+    __action166(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action915(
+fn __action915<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action373(&__start0, &__end0);
+    let __temp0 = __action373(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action167(__temp0, __0, __1, __2, __3)
+    __action167(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action916(
+fn __action916<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action849(__1, __2, __3, __4)?;
+    let __temp0 = __action849(
+        __1,
+        __2,
+        __3,
+        __4,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action398(__0, __temp0))
+    Ok(__action398(
+        __0,
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action917(
+fn __action917<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action850(__1, __2, __3)?;
+    let __temp0 = __action850(
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action398(__0, __temp0))
+    Ok(__action398(
+        __0,
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action918(
+fn __action918<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __5.2;
-    let __temp0 = __action851(__1, __2, __3, __4, __5)?;
+    let __temp0 = __action851(
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action398(__0, __temp0))
+    Ok(__action398(
+        __0,
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action919(
+fn __action919<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action852(__1, __2, __3, __4)?;
+    let __temp0 = __action852(
+        __1,
+        __2,
+        __3,
+        __4,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action398(__0, __temp0))
+    Ok(__action398(
+        __0,
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action920(
+fn __action920<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action853(__1, __2)?;
+    let __temp0 = __action853(
+        __1,
+        __2,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action398(__0, __temp0))
+    Ok(__action398(
+        __0,
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action921(
+fn __action921<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action854(__1)?;
+    let __temp0 = __action854(
+        __1,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action398(__0, __temp0))
+    Ok(__action398(
+        __0,
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action922(
+fn __action922<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action855(__1, __2, __3)?;
+    let __temp0 = __action855(
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action398(__0, __temp0))
+    Ok(__action398(
+        __0,
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action923(
+fn __action923<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action856(__1, __2)?;
+    let __temp0 = __action856(
+        __1,
+        __2,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action398(__0, __temp0))
+    Ok(__action398(
+        __0,
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action924(
+fn __action924<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action849(__0, __1, __2, __3)?;
+    let __temp0 = __action849(
+        __0,
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action837(__temp0, __4, __5))
+    Ok(__action837(
+        __temp0,
+        __4,
+        __5,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action925(
+fn __action925<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action850(__0, __1, __2)?;
+    let __temp0 = __action850(
+        __0,
+        __1,
+        __2,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action837(__temp0, __3, __4))
+    Ok(__action837(
+        __temp0,
+        __3,
+        __4,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action926(
+fn __action926<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
@@ -40719,373 +44950,516 @@ fn __action926(
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __4.2;
-    let __temp0 = __action851(__0, __1, __2, __3, __4)?;
+    let __temp0 = __action851(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action837(__temp0, __5, __6))
+    Ok(__action837(
+        __temp0,
+        __5,
+        __6,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action927(
+fn __action927<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action852(__0, __1, __2, __3)?;
+    let __temp0 = __action852(
+        __0,
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action837(__temp0, __4, __5))
+    Ok(__action837(
+        __temp0,
+        __4,
+        __5,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action928(
+fn __action928<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action853(__0, __1)?;
+    let __temp0 = __action853(
+        __0,
+        __1,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action837(__temp0, __2, __3))
+    Ok(__action837(
+        __temp0,
+        __2,
+        __3,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action929(
+fn __action929<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action854(__0)?;
+    let __temp0 = __action854(
+        __0,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action837(__temp0, __1, __2))
+    Ok(__action837(
+        __temp0,
+        __1,
+        __2,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action930(
+fn __action930<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action855(__0, __1, __2)?;
+    let __temp0 = __action855(
+        __0,
+        __1,
+        __2,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action837(__temp0, __3, __4))
+    Ok(__action837(
+        __temp0,
+        __3,
+        __4,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action931(
+fn __action931<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action856(__0, __1)?;
+    let __temp0 = __action856(
+        __0,
+        __1,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action837(__temp0, __2, __3))
+    Ok(__action837(
+        __temp0,
+        __2,
+        __3,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action932(
+fn __action932<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action849(__0, __1, __2, __3)?;
+    let __temp0 = __action849(
+        __0,
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action838(__temp0, __4))
+    Ok(__action838(
+        __temp0,
+        __4,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action933(
+fn __action933<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action850(__0, __1, __2)?;
+    let __temp0 = __action850(
+        __0,
+        __1,
+        __2,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action838(__temp0, __3))
+    Ok(__action838(
+        __temp0,
+        __3,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action934(
+fn __action934<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __4.2;
-    let __temp0 = __action851(__0, __1, __2, __3, __4)?;
+    let __temp0 = __action851(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action838(__temp0, __5))
+    Ok(__action838(
+        __temp0,
+        __5,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action935(
+fn __action935<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action852(__0, __1, __2, __3)?;
+    let __temp0 = __action852(
+        __0,
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action838(__temp0, __4))
+    Ok(__action838(
+        __temp0,
+        __4,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action936(
+fn __action936<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action853(__0, __1)?;
+    let __temp0 = __action853(
+        __0,
+        __1,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action838(__temp0, __2))
+    Ok(__action838(
+        __temp0,
+        __2,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action937(
+fn __action937<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action854(__0)?;
+    let __temp0 = __action854(
+        __0,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action838(__temp0, __1))
+    Ok(__action838(
+        __temp0,
+        __1,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action938(
+fn __action938<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action855(__0, __1, __2)?;
+    let __temp0 = __action855(
+        __0,
+        __1,
+        __2,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action838(__temp0, __3))
+    Ok(__action838(
+        __temp0,
+        __3,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action939(
+fn __action939<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action856(__0, __1)?;
+    let __temp0 = __action856(
+        __0,
+        __1,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action838(__temp0, __2))
+    Ok(__action838(
+        __temp0,
+        __2,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action940(
+fn __action940<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    core::option::Option<(
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    )>,
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __4.2;
-    let __temp0 = __action916(__0, __1, __2, __3, __4)?;
+    let __temp0 = __action916(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action396(__temp0))
+    Ok(__action396(
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action941(
+fn __action941<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    core::option::Option<(
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    )>,
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action917(__0, __1, __2, __3)?;
+    let __temp0 = __action917(
+        __0,
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action396(__temp0))
+    Ok(__action396(
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action942(
+fn __action942<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    core::option::Option<(
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    )>,
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __5.2;
-    let __temp0 = __action918(__0, __1, __2, __3, __4, __5)?;
+    let __temp0 = __action918(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action396(__temp0))
+    Ok(__action396(
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action943(
+fn __action943<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    core::option::Option<(
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    )>,
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __4.2;
-    let __temp0 = __action919(__0, __1, __2, __3, __4)?;
+    let __temp0 = __action919(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action396(__temp0))
+    Ok(__action396(
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action944(
+fn __action944<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
-) -> Result<
-    core::option::Option<(
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    )>,
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action920(__0, __1, __2)?;
+    let __temp0 = __action920(
+        __0,
+        __1,
+        __2,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action396(__temp0))
+    Ok(__action396(
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action945(
+fn __action945<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<
-    core::option::Option<(
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    )>,
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action921(__0, __1)?;
+    let __temp0 = __action921(
+        __0,
+        __1,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action396(__temp0))
+    Ok(__action396(
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action946(
+fn __action946<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<
-    core::option::Option<(
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    )>,
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action922(__0, __1, __2, __3)?;
+    let __temp0 = __action922(
+        __0,
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action396(__temp0))
+    Ok(__action396(
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action947(
+fn __action947<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<
-    core::option::Option<(
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    )>,
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action923(__0, __1, __2)?;
+    let __temp0 = __action923(
+        __0,
+        __1,
+        __2,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action396(__temp0))
+    Ok(__action396(
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action948(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action948<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
@@ -41093,42 +45467,59 @@ fn __action948(
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __5.2;
-    let __temp0 = __action940(__1, __2, __3, __4, __5)?;
+    let __temp0 = __action940(
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action833(__0, __temp0, __6, __7)
+    __action833(
+        __0,
+        __temp0,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action949(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action949<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action941(__1, __2, __3, __4)?;
+    let __temp0 = __action941(
+        __1,
+        __2,
+        __3,
+        __4,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action833(__0, __temp0, __5, __6)
+    __action833(
+        __0,
+        __temp0,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action950(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action950<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
@@ -41137,21 +45528,31 @@ fn __action950(
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __6.2;
-    let __temp0 = __action942(__1, __2, __3, __4, __5, __6)?;
+    let __temp0 = __action942(
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action833(__0, __temp0, __7, __8)
+    __action833(
+        __0,
+        __temp0,
+        __7,
+        __8,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action951(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action951<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
@@ -41159,159 +45560,217 @@ fn __action951(
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __5.2;
-    let __temp0 = __action943(__1, __2, __3, __4, __5)?;
+    let __temp0 = __action943(
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action833(__0, __temp0, __6, __7)
+    __action833(
+        __0,
+        __temp0,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action952(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action952<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action944(__1, __2, __3)?;
+    let __temp0 = __action944(
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action833(__0, __temp0, __4, __5)
+    __action833(
+        __0,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action953(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action953<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action945(__1, __2)?;
+    let __temp0 = __action945(
+        __1,
+        __2,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action833(__0, __temp0, __3, __4)
+    __action833(
+        __0,
+        __temp0,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action954(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action954<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action946(__1, __2, __3, __4)?;
+    let __temp0 = __action946(
+        __1,
+        __2,
+        __3,
+        __4,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action833(__0, __temp0, __5, __6)
+    __action833(
+        __0,
+        __temp0,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action955(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action955<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action947(__1, __2, __3)?;
+    let __temp0 = __action947(
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action833(__0, __temp0, __4, __5)
+    __action833(
+        __0,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action956(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action956<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action397(&__start0, &__end0);
+    let __temp0 = __action397(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action833(__0, __temp0, __1, __2)
+    __action833(
+        __0,
+        __temp0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action957(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action957<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __5.2;
-    let __temp0 = __action940(__1, __2, __3, __4, __5)?;
+    let __temp0 = __action940(
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action834(__0, __temp0, __6)
+    __action834(
+        __0,
+        __temp0,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action958(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action958<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action941(__1, __2, __3, __4)?;
+    let __temp0 = __action941(
+        __1,
+        __2,
+        __3,
+        __4,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action834(__0, __temp0, __5)
+    __action834(
+        __0,
+        __temp0,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action959(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action959<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
@@ -41319,509 +45778,629 @@ fn __action959(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __6.2;
-    let __temp0 = __action942(__1, __2, __3, __4, __5, __6)?;
+    let __temp0 = __action942(
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action834(__0, __temp0, __7)
+    __action834(
+        __0,
+        __temp0,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action960(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action960<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __5.2;
-    let __temp0 = __action943(__1, __2, __3, __4, __5)?;
+    let __temp0 = __action943(
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action834(__0, __temp0, __6)
+    __action834(
+        __0,
+        __temp0,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action961(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action961<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action944(__1, __2, __3)?;
+    let __temp0 = __action944(
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action834(__0, __temp0, __4)
+    __action834(
+        __0,
+        __temp0,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action962(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action962<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action945(__1, __2)?;
+    let __temp0 = __action945(
+        __1,
+        __2,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action834(__0, __temp0, __3)
+    __action834(
+        __0,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action963(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action963<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action946(__1, __2, __3, __4)?;
+    let __temp0 = __action946(
+        __1,
+        __2,
+        __3,
+        __4,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action834(__0, __temp0, __5)
+    __action834(
+        __0,
+        __temp0,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action964(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action964<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action947(__1, __2, __3)?;
+    let __temp0 = __action947(
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action834(__0, __temp0, __4)
+    __action834(
+        __0,
+        __temp0,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action965(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action965<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action397(&__start0, &__end0);
+    let __temp0 = __action397(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action834(__0, __temp0, __1)
+    __action834(
+        __0,
+        __temp0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action966(
+fn __action966<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
-) -> Option<Box<ast::Arg>> {
+) -> Option<Box<ast::Arg>>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action444(__1);
+    let __temp0 = __action444(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action403(__0, __temp0)
+    __action403(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action967(__0: (TextSize, token::Tok, TextSize)) -> Option<Box<ast::Arg>> {
+fn __action967<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> Option<Box<ast::Arg>>
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action445(&__start0, &__end0);
+    let __temp0 = __action445(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action403(__0, __temp0)
+    __action403(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action968(
+fn __action968<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action444(__1);
+    let __temp0 = __action444(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action857(__0, __temp0, __2, __3)
+    __action857(
+        __0,
+        __temp0,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action969(
+fn __action969<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action445(&__start0, &__end0);
+    let __temp0 = __action445(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action857(__0, __temp0, __1, __2)
+    __action857(
+        __0,
+        __temp0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action970(
+fn __action970<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action444(__1);
+    let __temp0 = __action444(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action858(__0, __temp0, __2, __3, __4)
+    __action858(
+        __0,
+        __temp0,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action971(
+fn __action971<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action445(&__start0, &__end0);
+    let __temp0 = __action445(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action858(__0, __temp0, __1, __2, __3)
+    __action858(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action972(
+fn __action972<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action444(__1);
+    let __temp0 = __action444(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action859(__0, __temp0)
+    __action859(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action973(
+fn __action973<
+>(
     __0: (TextSize, token::Tok, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action445(&__start0, &__end0);
+    let __temp0 = __action445(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action859(__0, __temp0)
+    __action859(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action974(
+fn __action974<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action444(__1);
+    let __temp0 = __action444(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action860(__0, __temp0, __2)
+    __action860(
+        __0,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action975(
+fn __action975<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action445(&__start0, &__end0);
+    let __temp0 = __action445(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action860(__0, __temp0, __1)
+    __action860(
+        __0,
+        __temp0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action976(
+fn __action976<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action968(__1, __2, __3, __4)?;
+    let __temp0 = __action968(
+        __1,
+        __2,
+        __3,
+        __4,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action406(__0, __temp0))
+    Ok(__action406(
+        __0,
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action977(
+fn __action977<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action969(__1, __2, __3)?;
+    let __temp0 = __action969(
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action406(__0, __temp0))
+    Ok(__action406(
+        __0,
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action978(
+fn __action978<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __5.2;
-    let __temp0 = __action970(__1, __2, __3, __4, __5)?;
+    let __temp0 = __action970(
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action406(__0, __temp0))
+    Ok(__action406(
+        __0,
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action979(
+fn __action979<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action971(__1, __2, __3, __4)?;
+    let __temp0 = __action971(
+        __1,
+        __2,
+        __3,
+        __4,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action406(__0, __temp0))
+    Ok(__action406(
+        __0,
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action980(
+fn __action980<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action972(__1, __2)?;
+    let __temp0 = __action972(
+        __1,
+        __2,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action406(__0, __temp0))
+    Ok(__action406(
+        __0,
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action981(
+fn __action981<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action973(__1)?;
+    let __temp0 = __action973(
+        __1,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action406(__0, __temp0))
+    Ok(__action406(
+        __0,
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action982(
+fn __action982<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action974(__1, __2, __3)?;
+    let __temp0 = __action974(
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action406(__0, __temp0))
+    Ok(__action406(
+        __0,
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action983(
+fn __action983<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<
-    (
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    ),
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>),__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action975(__1, __2)?;
+    let __temp0 = __action975(
+        __1,
+        __2,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action406(__0, __temp0))
+    Ok(__action406(
+        __0,
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action984(
+fn __action984<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action968(__0, __1, __2, __3)?;
+    let __temp0 = __action968(
+        __0,
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action845(__temp0, __4, __5))
+    Ok(__action845(
+        __temp0,
+        __4,
+        __5,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action985(
+fn __action985<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action969(__0, __1, __2)?;
+    let __temp0 = __action969(
+        __0,
+        __1,
+        __2,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action845(__temp0, __3, __4))
+    Ok(__action845(
+        __temp0,
+        __3,
+        __4,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action986(
+fn __action986<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
@@ -41829,373 +46408,516 @@ fn __action986(
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __4.2;
-    let __temp0 = __action970(__0, __1, __2, __3, __4)?;
+    let __temp0 = __action970(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action845(__temp0, __5, __6))
+    Ok(__action845(
+        __temp0,
+        __5,
+        __6,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action987(
+fn __action987<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action971(__0, __1, __2, __3)?;
+    let __temp0 = __action971(
+        __0,
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action845(__temp0, __4, __5))
+    Ok(__action845(
+        __temp0,
+        __4,
+        __5,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action988(
+fn __action988<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action972(__0, __1)?;
+    let __temp0 = __action972(
+        __0,
+        __1,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action845(__temp0, __2, __3))
+    Ok(__action845(
+        __temp0,
+        __2,
+        __3,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action989(
+fn __action989<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action973(__0)?;
+    let __temp0 = __action973(
+        __0,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action845(__temp0, __1, __2))
+    Ok(__action845(
+        __temp0,
+        __1,
+        __2,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action990(
+fn __action990<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action974(__0, __1, __2)?;
+    let __temp0 = __action974(
+        __0,
+        __1,
+        __2,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action845(__temp0, __3, __4))
+    Ok(__action845(
+        __temp0,
+        __3,
+        __4,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action991(
+fn __action991<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action975(__0, __1)?;
+    let __temp0 = __action975(
+        __0,
+        __1,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action845(__temp0, __2, __3))
+    Ok(__action845(
+        __temp0,
+        __2,
+        __3,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action992(
+fn __action992<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action968(__0, __1, __2, __3)?;
+    let __temp0 = __action968(
+        __0,
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action846(__temp0, __4))
+    Ok(__action846(
+        __temp0,
+        __4,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action993(
+fn __action993<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action969(__0, __1, __2)?;
+    let __temp0 = __action969(
+        __0,
+        __1,
+        __2,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action846(__temp0, __3))
+    Ok(__action846(
+        __temp0,
+        __3,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action994(
+fn __action994<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __4.2;
-    let __temp0 = __action970(__0, __1, __2, __3, __4)?;
+    let __temp0 = __action970(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action846(__temp0, __5))
+    Ok(__action846(
+        __temp0,
+        __5,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action995(
+fn __action995<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action971(__0, __1, __2, __3)?;
+    let __temp0 = __action971(
+        __0,
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action846(__temp0, __4))
+    Ok(__action846(
+        __temp0,
+        __4,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action996(
+fn __action996<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action972(__0, __1)?;
+    let __temp0 = __action972(
+        __0,
+        __1,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action846(__temp0, __2))
+    Ok(__action846(
+        __temp0,
+        __2,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action997(
+fn __action997<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action973(__0)?;
+    let __temp0 = __action973(
+        __0,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action846(__temp0, __1))
+    Ok(__action846(
+        __temp0,
+        __1,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action998(
+fn __action998<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action974(__0, __1, __2)?;
+    let __temp0 = __action974(
+        __0,
+        __1,
+        __2,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action846(__temp0, __3))
+    Ok(__action846(
+        __temp0,
+        __3,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action999(
+fn __action999<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action975(__0, __1)?;
+    let __temp0 = __action975(
+        __0,
+        __1,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action846(__temp0, __2))
+    Ok(__action846(
+        __temp0,
+        __2,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1000(
+fn __action1000<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    core::option::Option<(
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    )>,
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __4.2;
-    let __temp0 = __action976(__0, __1, __2, __3, __4)?;
+    let __temp0 = __action976(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action404(__temp0))
+    Ok(__action404(
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1001(
+fn __action1001<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    core::option::Option<(
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    )>,
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action977(__0, __1, __2, __3)?;
+    let __temp0 = __action977(
+        __0,
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action404(__temp0))
+    Ok(__action404(
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1002(
+fn __action1002<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    core::option::Option<(
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    )>,
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __5.2;
-    let __temp0 = __action978(__0, __1, __2, __3, __4, __5)?;
+    let __temp0 = __action978(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action404(__temp0))
+    Ok(__action404(
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1003(
+fn __action1003<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<
-    core::option::Option<(
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    )>,
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __4.2;
-    let __temp0 = __action979(__0, __1, __2, __3, __4)?;
+    let __temp0 = __action979(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action404(__temp0))
+    Ok(__action404(
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1004(
+fn __action1004<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
-) -> Result<
-    core::option::Option<(
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    )>,
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action980(__0, __1, __2)?;
+    let __temp0 = __action980(
+        __0,
+        __1,
+        __2,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action404(__temp0))
+    Ok(__action404(
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1005(
+fn __action1005<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<
-    core::option::Option<(
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    )>,
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action981(__0, __1)?;
+    let __temp0 = __action981(
+        __0,
+        __1,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action404(__temp0))
+    Ok(__action404(
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1006(
+fn __action1006<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Arg, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<
-    core::option::Option<(
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    )>,
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action982(__0, __1, __2, __3)?;
+    let __temp0 = __action982(
+        __0,
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action404(__temp0))
+    Ok(__action404(
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1007(
+fn __action1007<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<
-    core::option::Option<(
-        Option<Box<ast::Arg>>,
-        Vec<ast::ArgWithDefault>,
-        Option<Box<ast::Arg>>,
-    )>,
-    __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-> {
+) -> Result<core::option::Option<(Option<Box<ast::Arg>>, Vec<ast::ArgWithDefault>, Option<Box<ast::Arg>>)>,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action983(__0, __1, __2)?;
+    let __temp0 = __action983(
+        __0,
+        __1,
+        __2,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    Ok(__action404(__temp0))
+    Ok(__action404(
+        __temp0,
+    ))
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1008(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1008<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
@@ -42203,42 +46925,59 @@ fn __action1008(
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __5.2;
-    let __temp0 = __action1000(__1, __2, __3, __4, __5)?;
+    let __temp0 = __action1000(
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action841(__0, __temp0, __6, __7)
+    __action841(
+        __0,
+        __temp0,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1009(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1009<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action1001(__1, __2, __3, __4)?;
+    let __temp0 = __action1001(
+        __1,
+        __2,
+        __3,
+        __4,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action841(__0, __temp0, __5, __6)
+    __action841(
+        __0,
+        __temp0,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1010(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1010<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
@@ -42247,21 +46986,31 @@ fn __action1010(
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __6.2;
-    let __temp0 = __action1002(__1, __2, __3, __4, __5, __6)?;
+    let __temp0 = __action1002(
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action841(__0, __temp0, __7, __8)
+    __action841(
+        __0,
+        __temp0,
+        __7,
+        __8,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1011(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1011<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
@@ -42269,159 +47018,217 @@ fn __action1011(
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __5.2;
-    let __temp0 = __action1003(__1, __2, __3, __4, __5)?;
+    let __temp0 = __action1003(
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action841(__0, __temp0, __6, __7)
+    __action841(
+        __0,
+        __temp0,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1012(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1012<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action1004(__1, __2, __3)?;
+    let __temp0 = __action1004(
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action841(__0, __temp0, __4, __5)
+    __action841(
+        __0,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1013(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1013<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1005(__1, __2)?;
+    let __temp0 = __action1005(
+        __1,
+        __2,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action841(__0, __temp0, __3, __4)
+    __action841(
+        __0,
+        __temp0,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1014(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1014<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action1006(__1, __2, __3, __4)?;
+    let __temp0 = __action1006(
+        __1,
+        __2,
+        __3,
+        __4,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action841(__0, __temp0, __5, __6)
+    __action841(
+        __0,
+        __temp0,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1015(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1015<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action1007(__1, __2, __3)?;
+    let __temp0 = __action1007(
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action841(__0, __temp0, __4, __5)
+    __action841(
+        __0,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1016(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1016<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action405(&__start0, &__end0);
+    let __temp0 = __action405(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action841(__0, __temp0, __1, __2)
+    __action841(
+        __0,
+        __temp0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1017(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1017<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __5.2;
-    let __temp0 = __action1000(__1, __2, __3, __4, __5)?;
+    let __temp0 = __action1000(
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action842(__0, __temp0, __6)
+    __action842(
+        __0,
+        __temp0,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1018(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1018<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action1001(__1, __2, __3, __4)?;
+    let __temp0 = __action1001(
+        __1,
+        __2,
+        __3,
+        __4,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action842(__0, __temp0, __5)
+    __action842(
+        __0,
+        __temp0,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1019(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1019<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
@@ -42429,210 +47236,315 @@ fn __action1019(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __6.2;
-    let __temp0 = __action1002(__1, __2, __3, __4, __5, __6)?;
+    let __temp0 = __action1002(
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action842(__0, __temp0, __7)
+    __action842(
+        __0,
+        __temp0,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1020(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1020<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __5.2;
-    let __temp0 = __action1003(__1, __2, __3, __4, __5)?;
+    let __temp0 = __action1003(
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action842(__0, __temp0, __6)
+    __action842(
+        __0,
+        __temp0,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1021(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1021<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action1004(__1, __2, __3)?;
+    let __temp0 = __action1004(
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action842(__0, __temp0, __4)
+    __action842(
+        __0,
+        __temp0,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1022(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1022<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1005(__1, __2)?;
+    let __temp0 = __action1005(
+        __1,
+        __2,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action842(__0, __temp0, __3)
+    __action842(
+        __0,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1023(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1023<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action1006(__1, __2, __3, __4)?;
+    let __temp0 = __action1006(
+        __1,
+        __2,
+        __3,
+        __4,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action842(__0, __temp0, __5)
+    __action842(
+        __0,
+        __temp0,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1024(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1024<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action1007(__1, __2, __3)?;
+    let __temp0 = __action1007(
+        __1,
+        __2,
+        __3,
+    )?;
     let __temp0 = (__start0, __temp0, __end0);
-    __action842(__0, __temp0, __4)
+    __action842(
+        __0,
+        __temp0,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1025(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1025<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action405(&__start0, &__end0);
+    let __temp0 = __action405(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action842(__0, __temp0, __1)
+    __action842(
+        __0,
+        __temp0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1026(
+fn __action1026<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> core::option::Option<ast::Expr> {
+) -> core::option::Option<ast::Expr>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action334(__0, __1);
+    let __temp0 = __action334(
+        __0,
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action332(__temp0)
+    __action332(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1027(
+fn __action1027<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __2.0;
     let __end0 = __3.2;
-    let __temp0 = __action1026(__2, __3);
+    let __temp0 = __action1026(
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action692(__0, __1, __temp0, __4)
+    __action692(
+        __0,
+        __1,
+        __temp0,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1028(
+fn __action1028<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action333(&__start0, &__end0);
+    let __temp0 = __action333(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action692(__0, __1, __temp0, __2)
+    __action692(
+        __0,
+        __1,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1029(
+fn __action1029<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<ast::Expr> {
+) -> alloc::vec::Vec<ast::Expr>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action527(__0, __1);
+    let __temp0 = __action527(
+        __0,
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action533(__temp0)
+    __action533(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1030(
+fn __action1030<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<ast::Expr> {
+) -> alloc::vec::Vec<ast::Expr>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action527(__1, __2);
+    let __temp0 = __action527(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action534(__0, __temp0)
+    __action534(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1031(
+fn __action1031<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action525(&__start0, &__end0);
+    let __temp0 = __action525(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action700(__0, __1, __2, __temp0, __3, __4, __5)
+    __action700(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1032(
+fn __action1032<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -42640,63 +47552,111 @@ fn __action1032(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action526(__3);
+    let __temp0 = __action526(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action700(__0, __1, __2, __temp0, __4, __5, __6)
+    __action700(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1033(
+fn __action1033<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action525(&__start0, &__end0);
+    let __temp0 = __action525(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action701(__0, __1, __2, __temp0, __3, __4)
+    __action701(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1034(
+fn __action1034<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action526(__3);
+    let __temp0 = __action526(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action701(__0, __1, __2, __temp0, __4, __5)
+    __action701(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1035(
+fn __action1035<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action525(&__start0, &__end0);
+    let __temp0 = __action525(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action718(__0, __1, __2, __temp0, __3, __4, __5)
+    __action718(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1036(
+fn __action1036<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -42704,144 +47664,245 @@ fn __action1036(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action526(__3);
+    let __temp0 = __action526(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action718(__0, __1, __2, __temp0, __4, __5, __6)
+    __action718(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1037(
+fn __action1037<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action525(&__start0, &__end0);
+    let __temp0 = __action525(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action719(__0, __1, __2, __temp0, __3, __4)
+    __action719(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1038(
+fn __action1038<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action526(__3);
+    let __temp0 = __action526(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action719(__0, __1, __2, __temp0, __4, __5)
+    __action719(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1039(
+fn __action1039<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::WithItem, TextSize),
-) -> alloc::vec::Vec<ast::WithItem> {
+) -> alloc::vec::Vec<ast::WithItem>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action283(__0, __1);
+    let __temp0 = __action283(
+        __0,
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action277(__temp0)
+    __action277(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1040(
+fn __action1040<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::WithItem, TextSize),
-) -> alloc::vec::Vec<ast::WithItem> {
+) -> alloc::vec::Vec<ast::WithItem>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action283(__1, __2);
+    let __temp0 = __action283(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action278(__0, __temp0)
+    __action278(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1041(
+fn __action1041<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::WithItem>>, TextSize),
     __2: (TextSize, ast::WithItem, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action281(&__start0, &__end0);
+    let __temp0 = __action281(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action627(__0, __1, __2, __temp0, __3, __4)
+    __action627(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1042(
+fn __action1042<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::WithItem>>, TextSize),
     __2: (TextSize, ast::WithItem, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action282(__3);
+    let __temp0 = __action282(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action627(__0, __1, __2, __temp0, __4, __5)
+    __action627(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1043(
+fn __action1043<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::WithItem>>, TextSize),
     __2: (TextSize, ast::WithItem, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     let __start0 = __2.2;
     let __end0 = __3.0;
-    let __temp0 = __action281(&__start0, &__end0);
+    let __temp0 = __action281(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action628(__0, __1, __2, __temp0, __3)
+    __action628(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1044(
+fn __action1044<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::WithItem>>, TextSize),
     __2: (TextSize, ast::WithItem, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action282(__3);
+    let __temp0 = __action282(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action628(__0, __1, __2, __temp0, __4)
+    __action628(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1045(
+fn __action1045<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> core::option::Option<ast::Expr> {
+) -> core::option::Option<ast::Expr>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action272(__0, __1);
+    let __temp0 = __action272(
+        __0,
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action270(__temp0)
+    __action270(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1046(
+fn __action1046<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -42851,16 +47912,30 @@ fn __action1046(
     __6: (TextSize, ast::Expr, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __5.0;
     let __end0 = __6.2;
-    let __temp0 = __action1045(__5, __6);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action780(__0, __1, __2, __3, __4, __temp0, __7, __8)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1047(
+    let __temp0 = __action1045(
+        __5,
+        __6,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action780(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+        __7,
+        __8,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1047<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -42868,16 +47943,30 @@ fn __action1047(
     __4: (TextSize, ast::Arguments, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __4.2;
     let __end0 = __5.0;
-    let __temp0 = __action271(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action780(__0, __1, __2, __3, __4, __temp0, __5, __6)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1048(
+    let __temp0 = __action271(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action780(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+        __5,
+        __6,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1048<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
@@ -42886,288 +47975,478 @@ fn __action1048(
     __5: (TextSize, ast::Expr, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __4.0;
     let __end0 = __5.2;
-    let __temp0 = __action1045(__4, __5);
+    let __temp0 = __action1045(
+        __4,
+        __5,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action781(__0, __1, __2, __3, __temp0, __6, __7)
+    __action781(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1049(
+fn __action1049<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, ast::Arguments, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action271(&__start0, &__end0);
+    let __temp0 = __action271(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action781(__0, __1, __2, __3, __temp0, __4, __5)
+    __action781(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1050(
+fn __action1050<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Identifier, TextSize),
-) -> alloc::vec::Vec<(token::Tok, ast::Identifier)> {
+) -> alloc::vec::Vec<(token::Tok, ast::Identifier)>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action339(__0, __1);
+    let __temp0 = __action339(
+        __0,
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action337(__temp0)
+    __action337(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1051(
-    __0: (
-        TextSize,
-        alloc::vec::Vec<(token::Tok, ast::Identifier)>,
-        TextSize,
-    ),
+fn __action1051<
+>(
+    __0: (TextSize, alloc::vec::Vec<(token::Tok, ast::Identifier)>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> alloc::vec::Vec<(token::Tok, ast::Identifier)> {
+) -> alloc::vec::Vec<(token::Tok, ast::Identifier)>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action339(__1, __2);
+    let __temp0 = __action339(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action338(__0, __temp0)
+    __action338(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1052(
+fn __action1052<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> core::option::Option<ast::Expr> {
+) -> core::option::Option<ast::Expr>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action262(__0, __1);
+    let __temp0 = __action262(
+        __0,
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action260(__temp0)
+    __action260(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1053(
+fn __action1053<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Arg {
+) -> ast::Arg
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1052(__1, __2);
+    let __temp0 = __action1052(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action762(__0, __temp0, __3)
+    __action762(
+        __0,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1054(
+fn __action1054<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Arg {
+) -> ast::Arg
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action261(&__start0, &__end0);
+    let __temp0 = __action261(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action762(__0, __temp0, __1)
+    __action762(
+        __0,
+        __temp0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1055(
+fn __action1055<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::ArgWithDefault {
+) -> ast::ArgWithDefault
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1052(__1, __2);
+    let __temp0 = __action1052(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action900(__0, __temp0, __3)
+    __action900(
+        __0,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1056(
+fn __action1056<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::ArgWithDefault {
+) -> ast::ArgWithDefault
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action261(&__start0, &__end0);
+    let __temp0 = __action261(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action900(__0, __temp0, __1)
+    __action900(
+        __0,
+        __temp0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1057(
+fn __action1057<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> core::option::Option<ast::Expr> {
+) -> core::option::Option<ast::Expr>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action259(__0, __1);
+    let __temp0 = __action259(
+        __0,
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action257(__temp0)
+    __action257(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1058(
+fn __action1058<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Arg {
+) -> ast::Arg
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1057(__1, __2);
+    let __temp0 = __action1057(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action883(__0, __temp0, __3)
+    __action883(
+        __0,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1059(
+fn __action1059<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Arg {
+) -> ast::Arg
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action258(&__start0, &__end0);
+    let __temp0 = __action258(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action883(__0, __temp0, __1)
+    __action883(
+        __0,
+        __temp0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1060(__0: (TextSize, token::Tok, TextSize)) -> alloc::vec::Vec<token::Tok> {
+fn __action1060<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> alloc::vec::Vec<token::Tok>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action371(__0);
+    let __temp0 = __action371(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action374(__temp0)
+    __action374(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1061(
+fn __action1061<
+>(
     __0: (TextSize, alloc::vec::Vec<token::Tok>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<token::Tok> {
+) -> alloc::vec::Vec<token::Tok>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action371(__1);
+    let __temp0 = __action371(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action375(__0, __temp0)
+    __action375(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1062(
+fn __action1062<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Mod {
+) -> ast::Mod
+{
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action369(&__start0, &__end0);
+    let __temp0 = __action369(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action896(__0, __1, __temp0, __2)
+    __action896(
+        __0,
+        __1,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1063(
+fn __action1063<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<token::Tok>, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Mod {
+) -> ast::Mod
+{
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action370(__2);
+    let __temp0 = __action370(
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action896(__0, __1, __temp0, __3)
+    __action896(
+        __0,
+        __1,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1064(
+fn __action1064<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Identifier, TextSize),
-) -> core::option::Option<ast::Identifier> {
+) -> core::option::Option<ast::Identifier>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action382(__0, __1);
+    let __temp0 = __action382(
+        __0,
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action380(__temp0)
+    __action380(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1065(
+fn __action1065<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Alias {
+) -> ast::Alias
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1064(__1, __2);
+    let __temp0 = __action1064(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action792(__0, __temp0, __3)
+    __action792(
+        __0,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1066(
+fn __action1066<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Alias {
+) -> ast::Alias
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action381(&__start0, &__end0);
+    let __temp0 = __action381(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action792(__0, __temp0, __1)
+    __action792(
+        __0,
+        __temp0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1067(
+fn __action1067<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> ast::Alias {
+) -> ast::Alias
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1064(__1, __2);
+    let __temp0 = __action1064(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action793(__0, __temp0, __3)
+    __action793(
+        __0,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1068(
+fn __action1068<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, TextSize, TextSize),
-) -> ast::Alias {
+) -> ast::Alias
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action381(&__start0, &__end0);
+    let __temp0 = __action381(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action793(__0, __temp0, __1)
+    __action793(
+        __0,
+        __temp0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1069(
+fn __action1069<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
-) -> core::option::Option<ast::Suite> {
+) -> core::option::Option<ast::Suite>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action304(__0, __1, __2);
+    let __temp0 = __action304(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action302(__temp0)
+    __action302(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1070(
+fn __action1070<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -43178,16 +48457,31 @@ fn __action1070(
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, token::Tok, TextSize),
     __9: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __7.0;
     let __end0 = __9.2;
-    let __temp0 = __action1069(__7, __8, __9);
+    let __temp0 = __action1069(
+        __7,
+        __8,
+        __9,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action778(__0, __1, __2, __3, __4, __5, __6, __temp0)
+    __action778(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1071(
+fn __action1071<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -43195,16 +48489,30 @@ fn __action1071(
     __4: (TextSize, ast::Expr, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action303(&__start0, &__end0);
+    let __temp0 = __action303(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action778(__0, __1, __2, __3, __4, __5, __6, __temp0)
+    __action778(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1072(
+fn __action1072<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -43214,73 +48522,117 @@ fn __action1072(
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __6.0;
     let __end0 = __8.2;
-    let __temp0 = __action1069(__6, __7, __8);
+    let __temp0 = __action1069(
+        __6,
+        __7,
+        __8,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action779(__0, __1, __2, __3, __4, __5, __temp0)
+    __action779(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1073(
+fn __action1073<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action303(&__start0, &__end0);
+    let __temp0 = __action303(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action779(__0, __1, __2, __3, __4, __5, __temp0)
+    __action779(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1074(
+fn __action1074<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-    __4: (
-        TextSize,
-        alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>,
-        TextSize,
-    ),
+    __4: (TextSize, alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __5.0;
     let __end0 = __7.2;
-    let __temp0 = __action1069(__5, __6, __7);
+    let __temp0 = __action1069(
+        __5,
+        __6,
+        __7,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action791(__0, __1, __2, __3, __4, __temp0)
+    __action791(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1075(
+fn __action1075<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-    __4: (
-        TextSize,
-        alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>,
-        TextSize,
-    ),
-) -> ast::Stmt {
+    __4: (TextSize, alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>, TextSize),
+) -> ast::Stmt
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action303(&__start0, &__end0);
+    let __temp0 = __action303(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action791(__0, __1, __2, __3, __4, __temp0)
+    __action791(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1076(
+fn __action1076<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -43290,32 +48642,59 @@ fn __action1076(
     __6: (TextSize, ast::Suite, TextSize),
     __7: (TextSize, core::option::Option<ast::Suite>, TextSize),
     __8: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __4.0;
     let __end0 = __6.2;
-    let __temp0 = __action1069(__4, __5, __6);
+    let __temp0 = __action1069(
+        __4,
+        __5,
+        __6,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action897(__0, __1, __2, __3, __temp0, __7, __8)
+    __action897(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __7,
+        __8,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1077(
+fn __action1077<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ExceptHandler>, TextSize),
     __4: (TextSize, core::option::Option<ast::Suite>, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action303(&__start0, &__end0);
+    let __temp0 = __action303(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action897(__0, __1, __2, __3, __temp0, __4, __5)
+    __action897(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1078(
+fn __action1078<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -43325,32 +48704,59 @@ fn __action1078(
     __6: (TextSize, ast::Suite, TextSize),
     __7: (TextSize, core::option::Option<ast::Suite>, TextSize),
     __8: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __4.0;
     let __end0 = __6.2;
-    let __temp0 = __action1069(__4, __5, __6);
+    let __temp0 = __action1069(
+        __4,
+        __5,
+        __6,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action898(__0, __1, __2, __3, __temp0, __7, __8)
+    __action898(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __7,
+        __8,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1079(
+fn __action1079<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ExceptHandler>, TextSize),
     __4: (TextSize, core::option::Option<ast::Suite>, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action303(&__start0, &__end0);
+    let __temp0 = __action303(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action898(__0, __1, __2, __3, __temp0, __4, __5)
+    __action898(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1080(
+fn __action1080<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -43358,59 +48764,101 @@ fn __action1080(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __4.0;
     let __end0 = __6.2;
-    let __temp0 = __action1069(__4, __5, __6);
+    let __temp0 = __action1069(
+        __4,
+        __5,
+        __6,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action903(__0, __1, __2, __3, __temp0)
+    __action903(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1081(
+fn __action1081<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action303(&__start0, &__end0);
+    let __temp0 = __action303(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action903(__0, __1, __2, __3, __temp0)
+    __action903(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1082(
+fn __action1082<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
-) -> core::option::Option<ast::Suite> {
+) -> core::option::Option<ast::Suite>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action297(__0, __1, __2);
+    let __temp0 = __action297(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action295(__temp0)
+    __action295(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1083(
+fn __action1083<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __3.0;
     let __end0 = __5.2;
-    let __temp0 = __action297(__3, __4, __5);
+    let __temp0 = __action297(
+        __3,
+        __4,
+        __5,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action899(__0, __1, __2, __temp0)
+    __action899(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1084(
+fn __action1084<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -43422,16 +48870,32 @@ fn __action1084(
     __8: (TextSize, token::Tok, TextSize),
     __9: (TextSize, ast::Suite, TextSize),
     __10: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __7.0;
     let __end0 = __9.2;
-    let __temp0 = __action1082(__7, __8, __9);
+    let __temp0 = __action1082(
+        __7,
+        __8,
+        __9,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1076(__0, __1, __2, __3, __4, __5, __6, __temp0, __10)
+    __action1076(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __temp0,
+        __10,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1085(
+fn __action1085<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -43440,16 +48904,31 @@ fn __action1085(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __6.2;
     let __end0 = __7.0;
-    let __temp0 = __action296(&__start0, &__end0);
+    let __temp0 = __action296(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1076(__0, __1, __2, __3, __4, __5, __6, __temp0, __7)
+    __action1076(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __temp0,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1086(
+fn __action1086<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -43458,31 +48937,56 @@ fn __action1086(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __4.0;
     let __end0 = __6.2;
-    let __temp0 = __action1082(__4, __5, __6);
+    let __temp0 = __action1082(
+        __4,
+        __5,
+        __6,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1077(__0, __1, __2, __3, __temp0, __7)
+    __action1077(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1087(
+fn __action1087<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ExceptHandler>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action296(&__start0, &__end0);
+    let __temp0 = __action296(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1077(__0, __1, __2, __3, __temp0, __4)
+    __action1077(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1088(
+fn __action1088<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -43494,16 +48998,32 @@ fn __action1088(
     __8: (TextSize, token::Tok, TextSize),
     __9: (TextSize, ast::Suite, TextSize),
     __10: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __7.0;
     let __end0 = __9.2;
-    let __temp0 = __action1082(__7, __8, __9);
+    let __temp0 = __action1082(
+        __7,
+        __8,
+        __9,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1078(__0, __1, __2, __3, __4, __5, __6, __temp0, __10)
+    __action1078(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __temp0,
+        __10,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1089(
+fn __action1089<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -43512,16 +49032,31 @@ fn __action1089(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __6.2;
     let __end0 = __7.0;
-    let __temp0 = __action296(&__start0, &__end0);
+    let __temp0 = __action296(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1078(__0, __1, __2, __3, __4, __5, __6, __temp0, __7)
+    __action1078(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __temp0,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1090(
+fn __action1090<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -43530,104 +49065,171 @@ fn __action1090(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __4.0;
     let __end0 = __6.2;
-    let __temp0 = __action1082(__4, __5, __6);
+    let __temp0 = __action1082(
+        __4,
+        __5,
+        __6,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1079(__0, __1, __2, __3, __temp0, __7)
+    __action1079(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1091(
+fn __action1091<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ExceptHandler>, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action296(&__start0, &__end0);
+    let __temp0 = __action296(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1079(__0, __1, __2, __3, __temp0, __4)
+    __action1079(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1092(
+fn __action1092<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> core::option::Option<ast::Expr> {
+) -> core::option::Option<ast::Expr>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action354(__0, __1);
+    let __temp0 = __action354(
+        __0,
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action352(__temp0)
+    __action352(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1093(
+fn __action1093<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __2.0;
     let __end0 = __3.2;
-    let __temp0 = __action1092(__2, __3);
+    let __temp0 = __action1092(
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action869(__0, __1, __temp0, __4)
+    __action869(
+        __0,
+        __1,
+        __temp0,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1094(
+fn __action1094<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, TextSize, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action353(&__start0, &__end0);
+    let __temp0 = __action353(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action869(__0, __1, __temp0, __2)
+    __action869(
+        __0,
+        __1,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1095(
+fn __action1095<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)> {
+) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action682(__0, __1, __2, __3);
+    let __temp0 = __action682(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action387(__temp0)
+    __action387(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1096(
-    __0: (
-        TextSize,
-        alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>,
-        TextSize,
-    ),
+fn __action1096<
+>(
+    __0: (TextSize, alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Suite, TextSize),
-) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)> {
+) -> alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>
+{
     let __start0 = __1.0;
     let __end0 = __4.2;
-    let __temp0 = __action682(__1, __2, __3, __4);
+    let __temp0 = __action682(
+        __1,
+        __2,
+        __3,
+        __4,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action388(__0, __temp0)
+    __action388(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1097(
+fn __action1097<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -43635,235 +49237,288 @@ fn __action1097(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __3.2;
     let __end0 = __4.0;
-    let __temp0 = __action305(&__start0, &__end0);
+    let __temp0 = __action305(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1074(__0, __1, __2, __3, __temp0, __4, __5, __6)
+    __action1074(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1098(
+fn __action1098<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-    __4: (
-        TextSize,
-        alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>,
-        TextSize,
-    ),
+    __4: (TextSize, alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action306(__4);
+    let __temp0 = __action306(
+        __4,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1074(__0, __1, __2, __3, __temp0, __5, __6, __7)
+    __action1074(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1099(
+fn __action1099<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action305(&__start0, &__end0);
+    let __temp0 = __action305(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1075(__0, __1, __2, __3, __temp0)
+    __action1075(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1100(
+fn __action1100<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-    __4: (
-        TextSize,
-        alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>,
-        TextSize,
-    ),
-) -> ast::Stmt {
+    __4: (TextSize, alloc::vec::Vec<(TextSize, ast::Expr, ast::Suite)>, TextSize),
+) -> ast::Stmt
+{
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action306(__4);
+    let __temp0 = __action306(
+        __4,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1075(__0, __1, __2, __3, __temp0)
+    __action1075(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1101(
+fn __action1101<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<ast::Expr> {
+) -> alloc::vec::Vec<ast::Expr>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action416(__0, __1);
+    let __temp0 = __action416(
+        __0,
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action414(__temp0)
+    __action414(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1102(
+fn __action1102<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<ast::Expr> {
+) -> alloc::vec::Vec<ast::Expr>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action416(__1, __2);
+    let __temp0 = __action416(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action415(__0, __temp0)
+    __action415(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1103(
-    __0: (
-        TextSize,
-        (
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        ),
-        TextSize,
-    ),
+fn __action1103<
+>(
+    __0: (TextSize, (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr), TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<(
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-)> {
+) -> alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action425(__0, __1);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action426(__temp0)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1104(
-    __0: (
-        TextSize,
-        alloc::vec::Vec<(
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        )>,
-        TextSize,
-    ),
-    __1: (
-        TextSize,
-        (
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        ),
-        TextSize,
-    ),
-    __2: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<(
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-)> {
+    let __temp0 = __action425(
+        __0,
+        __1,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action426(
+        __temp0,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1104<
+>(
+    __0: (TextSize, alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
+    __1: (TextSize, (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr), TextSize),
+    __2: (TextSize, token::Tok, TextSize),
+) -> alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action425(__1, __2);
+    let __temp0 = __action425(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action427(__0, __temp0)
+    __action427(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1105(
-    __0: (
-        TextSize,
-        core::option::Option<(
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        )>,
-        TextSize,
-    ),
-) -> Vec<(
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-)> {
+fn __action1105<
+>(
+    __0: (TextSize, core::option::Option<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
+) -> Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action423(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action227(__temp0, __0)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1106(
-    __0: (
-        TextSize,
-        alloc::vec::Vec<(
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        )>,
-        TextSize,
-    ),
-    __1: (
-        TextSize,
-        core::option::Option<(
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        )>,
-        TextSize,
-    ),
-) -> Vec<(
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-)> {
+    let __temp0 = __action423(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action227(
+        __temp0,
+        __0,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1106<
+>(
+    __0: (TextSize, alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
+    __1: (TextSize, core::option::Option<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
+) -> Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action424(__0);
+    let __temp0 = __action424(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action227(__temp0, __1)
+    __action227(
+        __temp0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1107(
+fn __action1107<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<ast::Expr> {
+) -> alloc::vec::Vec<ast::Expr>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action430(__0, __1);
+    let __temp0 = __action430(
+        __0,
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action428(__temp0)
+    __action428(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1108(
+fn __action1108<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<ast::Expr> {
+) -> alloc::vec::Vec<ast::Expr>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action430(__1, __2);
+    let __temp0 = __action430(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action429(__0, __temp0)
+    __action429(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1109(
+fn __action1109<
+>(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> core::option::Option<Vec<ast::Expr>> {
+) -> core::option::Option<Vec<ast::Expr>>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action530(__0, __1);
+    let __temp0 = __action530(
+        __0,
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action528(__temp0)
+    __action528(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1110(
+fn __action1110<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -43871,31 +49526,55 @@ fn __action1110(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1109(__1, __2);
+    let __temp0 = __action1109(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1031(__0, __temp0, __3, __4, __5, __6)
+    __action1031(
+        __0,
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1111(
+fn __action1111<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action529(&__start0, &__end0);
+    let __temp0 = __action529(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1031(__0, __temp0, __1, __2, __3, __4)
+    __action1031(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1112(
+fn __action1112<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -43904,62 +49583,110 @@ fn __action1112(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1109(__1, __2);
+    let __temp0 = __action1109(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1032(__0, __temp0, __3, __4, __5, __6, __7)
+    __action1032(
+        __0,
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1113(
+fn __action1113<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action529(&__start0, &__end0);
+    let __temp0 = __action529(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1032(__0, __temp0, __1, __2, __3, __4, __5)
+    __action1032(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1114(
+fn __action1114<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1109(__1, __2);
+    let __temp0 = __action1109(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1033(__0, __temp0, __3, __4, __5)
+    __action1033(
+        __0,
+        __temp0,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1115(
+fn __action1115<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action529(&__start0, &__end0);
+    let __temp0 = __action529(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1033(__0, __temp0, __1, __2, __3)
+    __action1033(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1116(
+fn __action1116<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -43967,31 +49694,55 @@ fn __action1116(
     __4: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1109(__1, __2);
+    let __temp0 = __action1109(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1034(__0, __temp0, __3, __4, __5, __6)
+    __action1034(
+        __0,
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1117(
+fn __action1117<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action529(&__start0, &__end0);
+    let __temp0 = __action529(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1034(__0, __temp0, __1, __2, __3, __4)
+    __action1034(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1118(
+fn __action1118<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -43999,31 +49750,55 @@ fn __action1118(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1109(__1, __2);
+    let __temp0 = __action1109(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1035(__0, __temp0, __3, __4, __5, __6)
+    __action1035(
+        __0,
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1119(
+fn __action1119<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action529(&__start0, &__end0);
+    let __temp0 = __action529(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1035(__0, __temp0, __1, __2, __3, __4)
+    __action1035(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1120(
+fn __action1120<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -44032,62 +49807,110 @@ fn __action1120(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1109(__1, __2);
+    let __temp0 = __action1109(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1036(__0, __temp0, __3, __4, __5, __6, __7)
+    __action1036(
+        __0,
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1121(
+fn __action1121<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action529(&__start0, &__end0);
+    let __temp0 = __action529(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1036(__0, __temp0, __1, __2, __3, __4, __5)
+    __action1036(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1122(
+fn __action1122<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1109(__1, __2);
+    let __temp0 = __action1109(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1037(__0, __temp0, __3, __4, __5)
+    __action1037(
+        __0,
+        __temp0,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1123(
+fn __action1123<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action529(&__start0, &__end0);
+    let __temp0 = __action529(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1037(__0, __temp0, __1, __2, __3)
+    __action1037(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1124(
+fn __action1124<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -44095,336 +49918,568 @@ fn __action1124(
     __4: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1109(__1, __2);
+    let __temp0 = __action1109(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1038(__0, __temp0, __3, __4, __5, __6)
+    __action1038(
+        __0,
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1125(
+fn __action1125<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, TextSize, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action529(&__start0, &__end0);
+    let __temp0 = __action529(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1038(__0, __temp0, __1, __2, __3, __4)
+    __action1038(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1126(
+fn __action1126<
+>(
     __0: (TextSize, ast::Pattern, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<ast::Pattern> {
+) -> alloc::vec::Vec<ast::Pattern>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action320(__0, __1);
+    let __temp0 = __action320(
+        __0,
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action318(__temp0)
+    __action318(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1127(
+fn __action1127<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     __1: (TextSize, ast::Pattern, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<ast::Pattern> {
+) -> alloc::vec::Vec<ast::Pattern>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action320(__1, __2);
+    let __temp0 = __action320(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action319(__0, __temp0)
+    __action319(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1128(
+fn __action1128<
+>(
     __0: (TextSize, core::option::Option<ast::Pattern>, TextSize),
-) -> Vec<ast::Pattern> {
+) -> Vec<ast::Pattern>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action385(&__start0, &__end0);
+    let __temp0 = __action385(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action317(__temp0, __0)
+    __action317(
+        __temp0,
+        __0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1129(
+fn __action1129<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     __1: (TextSize, core::option::Option<ast::Pattern>, TextSize),
-) -> Vec<ast::Pattern> {
+) -> Vec<ast::Pattern>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action386(__0);
+    let __temp0 = __action386(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action317(__temp0, __1)
+    __action317(
+        __temp0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1130(
+fn __action1130<
+>(
     __0: (TextSize, ast::Stmt, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<ast::Stmt> {
+) -> alloc::vec::Vec<ast::Stmt>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action368(__0, __1);
+    let __temp0 = __action368(
+        __0,
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action376(__temp0)
+    __action376(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1131(
+fn __action1131<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> alloc::vec::Vec<ast::Stmt> {
+) -> alloc::vec::Vec<ast::Stmt>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action368(__1, __2);
+    let __temp0 = __action368(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action377(__0, __temp0)
+    __action377(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1132(
+fn __action1132<
+>(
     __0: (TextSize, ast::Suite, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Suite {
+) -> ast::Suite
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action366(&__start0, &__end0);
+    let __temp0 = __action366(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action629(__0, __temp0, __1, __2, __3)
+    __action629(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1133(
+fn __action1133<
+>(
     __0: (TextSize, ast::Suite, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __2: (TextSize, ast::Stmt, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> ast::Suite {
+) -> ast::Suite
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action367(__1);
+    let __temp0 = __action367(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action629(__0, __temp0, __2, __3, __4)
+    __action629(
+        __0,
+        __temp0,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1134(
+fn __action1134<
+>(
     __0: (TextSize, ast::Suite, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Suite {
+) -> ast::Suite
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action366(&__start0, &__end0);
+    let __temp0 = __action366(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action630(__0, __temp0, __1, __2)
+    __action630(
+        __0,
+        __temp0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1135(
+fn __action1135<
+>(
     __0: (TextSize, ast::Suite, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __2: (TextSize, ast::Stmt, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Suite {
+) -> ast::Suite
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action367(__1);
+    let __temp0 = __action367(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action630(__0, __temp0, __2, __3)
+    __action630(
+        __0,
+        __temp0,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1136(
+fn __action1136<
+>(
     __0: (TextSize, ast::Stmt, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt> {
+) -> Vec<ast::Stmt>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action366(&__start0, &__end0);
+    let __temp0 = __action366(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action631(__temp0, __0, __1, __2)
+    __action631(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1137(
+fn __action1137<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt> {
+) -> Vec<ast::Stmt>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action367(__0);
+    let __temp0 = __action367(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action631(__temp0, __1, __2, __3)
+    __action631(
+        __temp0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1138(
+fn __action1138<
+>(
     __0: (TextSize, ast::Stmt, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt> {
+) -> Vec<ast::Stmt>
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action366(&__start0, &__end0);
+    let __temp0 = __action366(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action632(__temp0, __0, __1)
+    __action632(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1139(
+fn __action1139<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt> {
+) -> Vec<ast::Stmt>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action367(__0);
+    let __temp0 = __action367(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action632(__temp0, __1, __2)
+    __action632(
+        __temp0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1140(
+fn __action1140<
+>(
     __0: (TextSize, Vec<ast::Stmt>, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt> {
+) -> Vec<ast::Stmt>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action366(&__start0, &__end0);
+    let __temp0 = __action366(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action633(__0, __temp0, __1, __2, __3)
+    __action633(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1141(
+fn __action1141<
+>(
     __0: (TextSize, Vec<ast::Stmt>, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __2: (TextSize, ast::Stmt, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt> {
+) -> Vec<ast::Stmt>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action367(__1);
+    let __temp0 = __action367(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action633(__0, __temp0, __2, __3, __4)
+    __action633(
+        __0,
+        __temp0,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1142(
+fn __action1142<
+>(
     __0: (TextSize, Vec<ast::Stmt>, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt> {
+) -> Vec<ast::Stmt>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action366(&__start0, &__end0);
+    let __temp0 = __action366(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action634(__0, __temp0, __1, __2)
+    __action634(
+        __0,
+        __temp0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1143(
+fn __action1143<
+>(
     __0: (TextSize, Vec<ast::Stmt>, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __2: (TextSize, ast::Stmt, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Stmt> {
+) -> Vec<ast::Stmt>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action367(__1);
+    let __temp0 = __action367(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action634(__0, __temp0, __2, __3)
+    __action634(
+        __0,
+        __temp0,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1144(
+fn __action1144<
+>(
     __0: (TextSize, ast::Stmt, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Suite {
+) -> ast::Suite
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action366(&__start0, &__end0);
+    let __temp0 = __action366(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action635(__temp0, __0, __1, __2)
+    __action635(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1145(
+fn __action1145<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Suite {
+) -> ast::Suite
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action367(__0);
+    let __temp0 = __action367(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action635(__temp0, __1, __2, __3)
+    __action635(
+        __temp0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1146(
+fn __action1146<
+>(
     __0: (TextSize, ast::Stmt, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Suite {
+) -> ast::Suite
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action366(&__start0, &__end0);
+    let __temp0 = __action366(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action636(__temp0, __0, __1)
+    __action636(
+        __temp0,
+        __0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1147(
+fn __action1147<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Stmt>, TextSize),
     __1: (TextSize, ast::Stmt, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Suite {
+) -> ast::Suite
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action367(__0);
+    let __temp0 = __action367(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action636(__temp0, __1, __2)
+    __action636(
+        __temp0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1148(
+fn __action1148<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Identifier, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler {
+) -> ast::ExceptHandler
+{
     let __start0 = __1.0;
     let __end0 = __3.2;
-    let __temp0 = __action292(__1, __2, __3);
+    let __temp0 = __action292(
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action764(__0, __temp0, __4, __5)
+    __action764(
+        __0,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1149(
+fn __action1149<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -44432,257 +50487,461 @@ fn __action1149(
     __4: (TextSize, ast::Identifier, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler {
+) -> ast::ExceptHandler
+{
     let __start0 = __2.0;
     let __end0 = __4.2;
-    let __temp0 = __action292(__2, __3, __4);
+    let __temp0 = __action292(
+        __2,
+        __3,
+        __4,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action766(__0, __1, __temp0, __5, __6)
+    __action766(
+        __0,
+        __1,
+        __temp0,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1150(
+fn __action1150<
+>(
     __0: (TextSize, (String, StringKind, bool), TextSize),
-) -> (TextSize, (String, StringKind, bool), TextSize) {
+) -> (TextSize, (String, StringKind, bool), TextSize)
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action683(__0, __temp0)
+    __action683(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1151(
+fn __action1151<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action684(__0, __1, __2, __temp0)
+    __action684(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1152(
+fn __action1152<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action685(__0, __1, __2, __temp0)
+    __action685(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1153(
+fn __action1153<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action686(__0, __1, __2, __temp0)
+    __action686(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1154(
+fn __action1154<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action687(__0, __1, __temp0)
+    __action687(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1155(
+fn __action1155<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action688(__0, __1, __temp0)
+    __action688(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1156(
+fn __action1156<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action689(__0, __1, __2, __temp0)
+    __action689(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1157(
+fn __action1157<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action690(__0, __1, __2, __temp0)
+    __action690(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1158(
+fn __action1158<
+>(
     __0: (TextSize, ast::Pattern, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> Result<ast::Pattern, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Pattern,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action691(__0, __1, __2, __temp0)
+    __action691(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1159(
+fn __action1159<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1027(__0, __1, __2, __3, __temp0)
+    __action1027(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1160(
+fn __action1160<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1028(__0, __1, __temp0)
+    __action1028(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1161(__0: (TextSize, ast::Constant, TextSize)) -> ast::Expr {
+fn __action1161<
+>(
+    __0: (TextSize, ast::Constant, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action694(__0, __temp0)
+    __action694(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1162(__0: (TextSize, ast::Identifier, TextSize)) -> ast::Expr {
+fn __action1162<
+>(
+    __0: (TextSize, ast::Identifier, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action695(__0, __temp0)
+    __action695(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1163(
+fn __action1163<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action696(__0, __1, __2, __temp0)
+    __action696(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1164(
+fn __action1164<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action697(__0, __1, __2, __3, __temp0)
+    __action697(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1165(
+fn __action1165<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action698(__0, __1, __2, __3, __temp0)
+    __action698(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1166(
+fn __action1166<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action699(__0, __1, __2, __temp0)
+    __action699(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1167(
+fn __action1167<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1110(__0, __1, __2, __3, __4, __5, __temp0)
+    __action1110(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1168(
+fn __action1168<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1111(__0, __1, __2, __3, __temp0)
+    __action1111(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1169(
+fn __action1169<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -44690,298 +50949,544 @@ fn __action1169(
     __4: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1112(__0, __1, __2, __3, __4, __5, __6, __temp0)
+    __action1112(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1170(
+fn __action1170<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1113(__0, __1, __2, __3, __4, __temp0)
+    __action1113(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1171(
+fn __action1171<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1114(__0, __1, __2, __3, __4, __temp0)
+    __action1114(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1172(
+fn __action1172<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1115(__0, __1, __2, __temp0)
+    __action1115(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1173(
+fn __action1173<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1116(__0, __1, __2, __3, __4, __5, __temp0)
+    __action1116(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1174(
+fn __action1174<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1117(__0, __1, __2, __3, __temp0)
+    __action1117(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1175(
+fn __action1175<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action702(__0, __1, __temp0)
+    __action702(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1176(
+fn __action1176<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action703(__0, __1, __2, __3, __temp0)
+    __action703(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1177(
+fn __action1177<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action704(__0, __1, __2, __3, __temp0)
+    __action704(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1178(
+fn __action1178<
+>(
     __0: (TextSize, token::Tok, TextSize),
-    __1: (
-        TextSize,
-        core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>,
-        TextSize,
-    ),
+    __1: (TextSize, core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action705(__0, __1, __2, __temp0)
+    __action705(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1179(
+fn __action1179<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, (ast::Expr, ast::Expr), TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action706(__0, __1, __2, __3, __temp0)
+    __action706(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1180(
+fn __action1180<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action707(__0, __1, __2, __temp0)
+    __action707(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1181(
+fn __action1181<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action708(__0, __1, __2, __3, __temp0)
+    __action708(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1182(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
+fn __action1182<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action709(__0, __temp0)
+    __action709(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1183(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
+fn __action1183<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action710(__0, __temp0)
+    __action710(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1184(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
+fn __action1184<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action711(__0, __temp0)
+    __action711(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1185(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
+fn __action1185<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action712(__0, __temp0)
+    __action712(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1186(__0: (TextSize, ast::Constant, TextSize)) -> ast::Expr {
+fn __action1186<
+>(
+    __0: (TextSize, ast::Constant, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action714(__0, __temp0)
+    __action714(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1187(__0: (TextSize, ast::Identifier, TextSize)) -> ast::Expr {
+fn __action1187<
+>(
+    __0: (TextSize, ast::Identifier, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action715(__0, __temp0)
+    __action715(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1188(
+fn __action1188<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<Vec<ast::Expr>>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action716(__0, __1, __2, __temp0)
+    __action716(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1189(
+fn __action1189<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action717(__0, __1, __2, __3, __temp0)
+    __action717(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1190(
+fn __action1190<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1118(__0, __1, __2, __3, __4, __5, __temp0)
+    __action1118(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1191(
+fn __action1191<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1119(__0, __1, __2, __3, __temp0)
+    __action1119(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1192(
+fn __action1192<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -44989,338 +51494,611 @@ fn __action1192(
     __4: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1120(__0, __1, __2, __3, __4, __5, __6, __temp0)
+    __action1120(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1193(
+fn __action1193<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1121(__0, __1, __2, __3, __4, __temp0)
+    __action1121(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1194(
+fn __action1194<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1122(__0, __1, __2, __3, __4, __temp0)
+    __action1122(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1195(
+fn __action1195<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1123(__0, __1, __2, __temp0)
+    __action1123(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1196(
+fn __action1196<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1124(__0, __1, __2, __3, __4, __5, __temp0)
+    __action1124(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1197(
+fn __action1197<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1125(__0, __1, __2, __3, __temp0)
+    __action1125(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1198(
+fn __action1198<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action720(__0, __1, __temp0)
+    __action720(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1199(
+fn __action1199<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action721(__0, __1, __2, __3, __temp0)
+    __action721(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1200(
+fn __action1200<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action722(__0, __1, __2, __3, __temp0)
+    __action722(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1201(
+fn __action1201<
+>(
     __0: (TextSize, token::Tok, TextSize),
-    __1: (
-        TextSize,
-        core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>,
-        TextSize,
-    ),
+    __1: (TextSize, core::option::Option<Vec<(Option<Box<ast::Expr>>, ast::Expr)>>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action723(__0, __1, __2, __temp0)
+    __action723(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1202(
+fn __action1202<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, (ast::Expr, ast::Expr), TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action724(__0, __1, __2, __3, __temp0)
+    __action724(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1203(
+fn __action1203<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action725(__0, __1, __2, __temp0)
+    __action725(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1204(
+fn __action1204<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Vec<ast::Comprehension>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action726(__0, __1, __2, __3, __temp0)
+    __action726(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1205(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
+fn __action1205<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action727(__0, __temp0)
+    __action727(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1206(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
+fn __action1206<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action728(__0, __temp0)
+    __action728(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1207(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
+fn __action1207<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action729(__0, __temp0)
+    __action729(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1208(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
+fn __action1208<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action730(__0, __temp0)
+    __action730(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1209(
+fn __action1209<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ArgumentList, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action731(__0, __1, __2, __3, __temp0)
+    __action731(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1210(
+fn __action1210<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action732(__0, __1, __2, __3, __temp0)
+    __action732(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1211(
+fn __action1211<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action733(__0, __1, __2, __temp0)
+    __action733(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1212(
+fn __action1212<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ArgumentList, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action734(__0, __1, __2, __3, __temp0)
+    __action734(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1213(
+fn __action1213<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action735(__0, __1, __2, __3, __temp0)
+    __action735(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1214(
+fn __action1214<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action736(__0, __1, __2, __temp0)
+    __action736(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1215(
+fn __action1215<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action737(__0, __1, __temp0)
+    __action737(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1216(
+fn __action1216<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action738(__0, __1, __temp0)
+    __action738(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1217(__0: (TextSize, ast::Identifier, TextSize)) -> ast::Pattern {
+fn __action1217<
+>(
+    __0: (TextSize, ast::Identifier, TextSize),
+) -> ast::Pattern
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action739(__0, __temp0)
+    __action739(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1218(
+fn __action1218<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
@@ -45328,103 +52106,186 @@ fn __action1218(
     __4: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action742(__0, __1, __2, __3, __4, __5, __6, __temp0)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1219(
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action742(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __temp0,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1219<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action743(__0, __1, __2, __3, __4, __5, __temp0)
+    __action743(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1220(
+fn __action1220<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action744(__0, __1, __2, __3, __4, __temp0)
+    __action744(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1221(
+fn __action1221<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action745(__0, __1, __2, __3, __temp0)
+    __action745(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1222(
+fn __action1222<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action746(__0, __1, __2, __3, __4, __temp0)
+    __action746(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1223(
+fn __action1223<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action747(__0, __1, __2, __3, __temp0)
+    __action747(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1224(
+fn __action1224<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action748(__0, __1, __2, __temp0)
+    __action748(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1225(
+fn __action1225<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
@@ -45432,717 +52293,1286 @@ fn __action1225(
     __4: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action749(__0, __1, __2, __3, __4, __5, __6, __temp0)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1226(
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action749(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __temp0,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1226<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action750(__0, __1, __2, __3, __4, __5, __temp0)
+    __action750(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1227(
+fn __action1227<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action751(__0, __1, __2, __3, __4, __temp0)
+    __action751(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1228(
+fn __action1228<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<ast::Pattern>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action752(__0, __1, __2, __3, __temp0)
+    __action752(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1229(
+fn __action1229<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action753(__0, __1, __2, __3, __4, __temp0)
+    __action753(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1230(
+fn __action1230<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Vec<(ast::Identifier, ast::Pattern)>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action754(__0, __1, __2, __3, __temp0)
+    __action754(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1231(
+fn __action1231<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action755(__0, __1, __2, __temp0)
+    __action755(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1232(
+fn __action1232<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, alloc::vec::Vec<(ast::CmpOp, ast::Expr)>, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action756(__0, __1, __temp0)
+    __action756(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1233(
+fn __action1233<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, alloc::vec::Vec<(ast::CmpOp, ast::Expr)>, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action757(__0, __1, __temp0)
+    __action757(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1234(__0: (TextSize, ast::Constant, TextSize)) -> ast::Expr {
+fn __action1234<
+>(
+    __0: (TextSize, ast::Constant, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action758(__0, __temp0)
+    __action758(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1235(
+fn __action1235<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action759(__0, __1, __temp0)
+    __action759(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1236(
+fn __action1236<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action761(__0, __1, __temp0)
+    __action761(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1237(
+fn __action1237<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Arg {
+) -> ast::Arg
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1053(__0, __1, __2, __temp0)
+    __action1053(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1238(__0: (TextSize, ast::Identifier, TextSize)) -> ast::Arg {
+fn __action1238<
+>(
+    __0: (TextSize, ast::Identifier, TextSize),
+) -> ast::Arg
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1054(__0, __temp0)
+    __action1054(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1239(
+fn __action1239<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action767(__0, __1, __2, __temp0)
+    __action767(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1240(
+fn __action1240<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action768(__0, __1, __2, __temp0)
+    __action768(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1241(
+fn __action1241<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action769(__0, __1, __temp0)
+    __action769(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1242(
+fn __action1242<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action770(__0, __1, __2, __temp0)
+    __action770(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1243(
+fn __action1243<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, core::option::Option<ast::Expr>, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action771(__0, __1, __2, __3, __temp0)
+    __action771(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1244(
+fn __action1244<
+>(
     __0: (TextSize, ast::UnaryOp, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action772(__0, __1, __temp0)
+    __action772(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1245(
+fn __action1245<
+>(
     __0: (TextSize, ast::UnaryOp, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action773(__0, __1, __temp0)
+    __action773(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1246(__0: (TextSize, token::Tok, TextSize)) -> ast::Stmt {
+fn __action1246<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> ast::Stmt
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action774(__0, __temp0)
+    __action774(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1247(__0: (TextSize, token::Tok, TextSize)) -> ast::Stmt {
+fn __action1247<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> ast::Stmt
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action775(__0, __temp0)
+    __action775(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1248(
+fn __action1248<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Expr>, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action776(__0, __1, __temp0)
+    __action776(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1249(__0: (TextSize, ast::Expr, TextSize)) -> ast::Stmt {
+fn __action1249<
+>(
+    __0: (TextSize, ast::Expr, TextSize),
+) -> ast::Stmt
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action777(__0, __temp0)
+    __action777(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1250(
+fn __action1250<
+>(
     __0: (TextSize, ast::Expr, TextSize),
-    __1: (
-        TextSize,
-        core::option::Option<Vec<ast::Comprehension>>,
-        TextSize,
-    ),
-) -> (
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-) {
+    __1: (TextSize, core::option::Option<Vec<ast::Comprehension>>, TextSize),
+) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action782(__0, __1, __temp0)
+    __action782(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1251(
+fn __action1251<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> (
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-) {
+) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action783(__0, __1, __2, __temp0)
+    __action783(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1252(
+fn __action1252<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> (
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-) {
+) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action784(__0, __1, __temp0)
+    __action784(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1253(
+fn __action1253<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> (
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-) {
+) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action785(__0, __1, __temp0)
+    __action785(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1254(
+fn __action1254<
+>(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action786(__0, __1, __temp0)
+    __action786(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1255(__0: (TextSize, Vec<ast::Expr>, TextSize)) -> ast::Expr {
+fn __action1255<
+>(
+    __0: (TextSize, Vec<ast::Expr>, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action787(__0, __temp0)
+    __action787(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1256(
+fn __action1256<
+>(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action788(__0, __1, __temp0)
+    __action788(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1257(__0: (TextSize, Vec<ast::Expr>, TextSize)) -> ast::Expr {
+fn __action1257<
+>(
+    __0: (TextSize, Vec<ast::Expr>, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action789(__0, __temp0)
+    __action789(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1258(
+fn __action1258<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Identifier>, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action790(__0, __1, __temp0)
+    __action790(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1259(
+fn __action1259<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> ast::Alias {
+) -> ast::Alias
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1065(__0, __1, __2, __temp0)
+    __action1065(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1260(__0: (TextSize, ast::Identifier, TextSize)) -> ast::Alias {
+fn __action1260<
+>(
+    __0: (TextSize, ast::Identifier, TextSize),
+) -> ast::Alias
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1066(__0, __temp0)
+    __action1066(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1261(
+fn __action1261<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> ast::Alias {
+) -> ast::Alias
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1067(__0, __1, __2, __temp0)
+    __action1067(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1262(__0: (TextSize, ast::Identifier, TextSize)) -> ast::Alias {
+fn __action1262<
+>(
+    __0: (TextSize, ast::Identifier, TextSize),
+) -> ast::Alias
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1068(__0, __temp0)
+    __action1068(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1263(__0: (TextSize, Vec<ast::Alias>, TextSize)) -> Vec<ast::Alias> {
+fn __action1263<
+>(
+    __0: (TextSize, Vec<ast::Alias>, TextSize),
+) -> Vec<ast::Alias>
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action794(__0, __temp0)
+    __action794(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1264(
+fn __action1264<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Alias>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Alias> {
+) -> Vec<ast::Alias>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action795(__0, __1, __2, __3, __temp0)
+    __action795(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1265(
+fn __action1265<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Alias>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::Alias> {
+) -> Vec<ast::Alias>
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action796(__0, __1, __2, __temp0)
+    __action796(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1266(__0: (TextSize, token::Tok, TextSize)) -> Vec<ast::Alias> {
+fn __action1266<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> Vec<ast::Alias>
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action797(__0, __temp0)
+    __action797(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1267(
+fn __action1267<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Alias>, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action798(__0, __1, __temp0)
+    __action798(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1268(
+fn __action1268<
+>(
     __0: (TextSize, token::Tok, TextSize),
-    __1: (
-        TextSize,
-        (Option<ast::Int>, Option<ast::Identifier>),
-        TextSize,
-    ),
+    __1: (TextSize, (Option<ast::Int>, Option<ast::Identifier>), TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Vec<ast::Alias>, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action799(__0, __1, __2, __3, __temp0)
+    __action799(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1269(
+fn __action1269<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Arguments>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action800(__0, __1, __2, __3, __temp0)
+    __action800(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1270(__0: (TextSize, token::Tok, TextSize)) -> ast::Pattern {
+fn __action1270<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> ast::Pattern
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action801(__0, __temp0)
+    __action801(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1271(__0: (TextSize, token::Tok, TextSize)) -> ast::Pattern {
+fn __action1271<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> ast::Pattern
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action802(__0, __temp0)
+    __action802(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1272(__0: (TextSize, token::Tok, TextSize)) -> ast::Pattern {
+fn __action1272<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> ast::Pattern
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action803(__0, __temp0)
+    __action803(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1273(__0: (TextSize, ast::Expr, TextSize)) -> ast::Pattern {
+fn __action1273<
+>(
+    __0: (TextSize, ast::Expr, TextSize),
+) -> ast::Pattern
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action804(__0, __temp0)
+    __action804(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1274(__0: (TextSize, ast::Expr, TextSize)) -> ast::Pattern {
+fn __action1274<
+>(
+    __0: (TextSize, ast::Expr, TextSize),
+) -> ast::Pattern
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action805(__0, __temp0)
+    __action805(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1275(
-    __0: (
-        TextSize,
-        alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>,
-        TextSize,
-    ),
-) -> Result<ast::Pattern, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+fn __action1275<
+>(
+    __0: (TextSize, alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>, TextSize),
+) -> Result<ast::Pattern,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action806(__0, __temp0)
+    __action806(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1276(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
+fn __action1276<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action807(__0, __temp0)
+    __action807(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1277(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
+fn __action1277<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action808(__0, __temp0)
+    __action808(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1278(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
+fn __action1278<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action809(__0, __temp0)
+    __action809(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1279(
+fn __action1279<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action811(__0, __1, __temp0)
+    __action811(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1280(
+fn __action1280<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action812(__0, __1, __2, __3, __temp0)
+    __action812(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1281(
+fn __action1281<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action813(__0, __1, __2, __temp0)
+    __action813(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1282(
+fn __action1282<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action814(__0, __1, __2, __3, __4, __temp0)
+    __action814(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1283(
+fn __action1283<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action815(__0, __1, __2, __3, __temp0)
+    __action815(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1284(
+fn __action1284<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -46150,195 +53580,332 @@ fn __action1284(
     __4: (TextSize, ast::Identifier, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action816(__0, __1, __2, __3, __4, __5, __6, __temp0)
+    __action816(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1285(
+fn __action1285<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<(ast::Expr, ast::Pattern)>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Identifier, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action817(__0, __1, __2, __3, __4, __5, __temp0)
+    __action817(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1286(__0: (TextSize, ast::Identifier, TextSize)) -> ast::Expr {
+fn __action1286<
+>(
+    __0: (TextSize, ast::Identifier, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action819(__0, __temp0)
+    __action819(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1287(
+fn __action1287<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action820(__0, __1, __2, __temp0)
+    __action820(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1288(
+fn __action1288<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action821(__0, __1, __2, __temp0)
+    __action821(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1289(
+fn __action1289<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action826(__0, __temp0, __1, __2)
+    __action826(
+        __0,
+        __temp0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1290(
+fn __action1290<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Identifier>, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action827(__0, __1, __temp0)
+    __action827(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1291(
+fn __action1291<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action828(__0, __1, __temp0)
+    __action828(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1292(
+fn __action1292<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action829(__0, __1, __temp0)
+    __action829(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1293(__0: (TextSize, Vec<ast::Pattern>, TextSize)) -> ast::Pattern {
+fn __action1293<
+>(
+    __0: (TextSize, Vec<ast::Pattern>, TextSize),
+) -> ast::Pattern
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action830(__0, __temp0)
+    __action830(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1294(
+fn __action1294<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action831(__0, __1, __temp0)
+    __action831(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1295(
+fn __action1295<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action832(__0, __1, __temp0)
+    __action832(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1296(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1296<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action948(__0, __1, __2, __3, __4, __5, __6, __temp0)
+    __action948(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1297(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1297<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action949(__0, __1, __2, __3, __4, __5, __temp0)
+    __action949(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1298(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1298<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
@@ -46346,614 +53913,959 @@ fn __action1298(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __7.2;
     let __end0 = __7.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action950(__0, __1, __2, __3, __4, __5, __6, __7, __temp0)
+    __action950(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1299(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1299<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action951(__0, __1, __2, __3, __4, __5, __6, __temp0)
+    __action951(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1300(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1300<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action952(__0, __1, __2, __3, __4, __temp0)
+    __action952(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1301(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1301<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action953(__0, __1, __2, __3, __temp0)
+    __action953(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1302(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1302<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action954(__0, __1, __2, __3, __4, __5, __temp0)
+    __action954(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1303(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1303<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action955(__0, __1, __2, __3, __4, __temp0)
+    __action955(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1304(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1304<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action956(__0, __1, __temp0)
+    __action956(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1305(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1305<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action957(__0, __1, __2, __3, __4, __5, __temp0)
+    __action957(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1306(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1306<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action958(__0, __1, __2, __3, __4, __temp0)
+    __action958(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1307(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1307<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action959(__0, __1, __2, __3, __4, __5, __6, __temp0)
+    __action959(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1308(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1308<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action960(__0, __1, __2, __3, __4, __5, __temp0)
+    __action960(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1309(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1309<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action961(__0, __1, __2, __3, __temp0)
+    __action961(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1310(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1310<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action962(__0, __1, __2, __temp0)
+    __action962(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1311(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1311<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action963(__0, __1, __2, __3, __4, __temp0)
+    __action963(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1312(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1312<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action964(__0, __1, __2, __3, __temp0)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1313(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action964(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1313<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action965(__0, __temp0)
+    __action965(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1314(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1314<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action835(__0, __1, __2, __3, __temp0)
+    __action835(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1315(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1315<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action836(__0, __1, __2, __temp0)
+    __action836(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1316(
+fn __action1316<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action924(__0, __1, __2, __3, __4, __temp0)
+    __action924(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1317(
+fn __action1317<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action925(__0, __1, __2, __3, __temp0)
+    __action925(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1318(
+fn __action1318<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action926(__0, __1, __2, __3, __4, __5, __temp0)
+    __action926(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1319(
+fn __action1319<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action927(__0, __1, __2, __3, __4, __temp0)
+    __action927(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1320(
+fn __action1320<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action928(__0, __1, __2, __temp0)
+    __action928(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1321(
+fn __action1321<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action929(__0, __1, __temp0)
+    __action929(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1322(
+fn __action1322<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action930(__0, __1, __2, __3, __temp0)
+    __action930(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1323(
+fn __action1323<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action931(__0, __1, __2, __temp0)
+    __action931(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1324(
+fn __action1324<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action932(__0, __1, __2, __3, __temp0)
+    __action932(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1325(
+fn __action1325<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action933(__0, __1, __2, __temp0)
+    __action933(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1326(
+fn __action1326<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action934(__0, __1, __2, __3, __4, __temp0)
+    __action934(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1327(
+fn __action1327<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action935(__0, __1, __2, __3, __temp0)
+    __action935(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1328(
+fn __action1328<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action936(__0, __1, __temp0)
+    __action936(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1329(
+fn __action1329<
+>(
     __0: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action937(__0, __temp0)
+    __action937(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1330(
+fn __action1330<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action938(__0, __1, __2, __temp0)
+    __action938(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1331(
+fn __action1331<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action939(__0, __1, __temp0)
+    __action939(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1332(
+fn __action1332<
+>(
     __0: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Arguments {
+) -> ast::Arguments
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action839(__0, __1, __temp0)
+    __action839(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1333(__0: (TextSize, Option<Box<ast::Arg>>, TextSize)) -> ast::Arguments {
+fn __action1333<
+>(
+    __0: (TextSize, Option<Box<ast::Arg>>, TextSize),
+) -> ast::Arguments
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action840(__0, __temp0)
+    __action840(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1334(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1334<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1008(__0, __1, __2, __3, __4, __5, __6, __temp0)
+    __action1008(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1335(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1335<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1009(__0, __1, __2, __3, __4, __5, __temp0)
+    __action1009(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1336(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1336<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
@@ -46961,1038 +54873,1752 @@ fn __action1336(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __7.2;
     let __end0 = __7.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1010(__0, __1, __2, __3, __4, __5, __6, __7, __temp0)
+    __action1010(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1337(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1337<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1011(__0, __1, __2, __3, __4, __5, __6, __temp0)
+    __action1011(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1338(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1338<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1012(__0, __1, __2, __3, __4, __temp0)
+    __action1012(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1339(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1339<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1013(__0, __1, __2, __3, __temp0)
+    __action1013(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1340(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1340<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1014(__0, __1, __2, __3, __4, __5, __temp0)
+    __action1014(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1341(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1341<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1015(__0, __1, __2, __3, __4, __temp0)
+    __action1015(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1342(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1342<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1016(__0, __1, __temp0)
+    __action1016(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1343(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1343<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1017(__0, __1, __2, __3, __4, __5, __temp0)
+    __action1017(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1344(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1344<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1018(__0, __1, __2, __3, __4, __temp0)
+    __action1018(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1345(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1345<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1019(__0, __1, __2, __3, __4, __5, __6, __temp0)
+    __action1019(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1346(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1346<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1020(__0, __1, __2, __3, __4, __5, __temp0)
+    __action1020(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1347(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1347<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1021(__0, __1, __2, __3, __temp0)
+    __action1021(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1348(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1348<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1022(__0, __1, __2, __temp0)
+    __action1022(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1349(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1349<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1023(__0, __1, __2, __3, __4, __temp0)
+    __action1023(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1350(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1350<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1024(__0, __1, __2, __3, __temp0)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1351(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1024(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1351<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1025(__0, __temp0)
+    __action1025(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1352(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1352<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action843(__0, __1, __2, __3, __temp0)
+    __action843(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1353(
-    __0: (
-        TextSize,
-        (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>),
-        TextSize,
-    ),
+fn __action1353<
+>(
+    __0: (TextSize, (Vec<ast::ArgWithDefault>, Vec<ast::ArgWithDefault>), TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action844(__0, __1, __2, __temp0)
+    __action844(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1354(
+fn __action1354<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action984(__0, __1, __2, __3, __4, __temp0)
+    __action984(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1355(
+fn __action1355<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action985(__0, __1, __2, __3, __temp0)
+    __action985(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1356(
+fn __action1356<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action986(__0, __1, __2, __3, __4, __5, __temp0)
+    __action986(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1357(
+fn __action1357<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action987(__0, __1, __2, __3, __4, __temp0)
+    __action987(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1358(
+fn __action1358<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action988(__0, __1, __2, __temp0)
+    __action988(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1359(
+fn __action1359<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action989(__0, __1, __temp0)
+    __action989(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1360(
+fn __action1360<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action990(__0, __1, __2, __3, __temp0)
+    __action990(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1361(
+fn __action1361<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action991(__0, __1, __2, __temp0)
+    __action991(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1362(
+fn __action1362<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action992(__0, __1, __2, __3, __temp0)
+    __action992(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1363(
+fn __action1363<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action993(__0, __1, __2, __temp0)
+    __action993(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1364(
+fn __action1364<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action994(__0, __1, __2, __3, __4, __temp0)
+    __action994(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1365(
+fn __action1365<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action995(__0, __1, __2, __3, __temp0)
+    __action995(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1366(
+fn __action1366<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action996(__0, __1, __temp0)
+    __action996(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1367(
+fn __action1367<
+>(
     __0: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action997(__0, __temp0)
+    __action997(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1368(
+fn __action1368<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action998(__0, __1, __2, __temp0)
+    __action998(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1369(
+fn __action1369<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action999(__0, __1, __temp0)
+    __action999(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1370(
+fn __action1370<
+>(
     __0: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Arguments {
+) -> ast::Arguments
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action847(__0, __1, __temp0)
+    __action847(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1371(__0: (TextSize, Option<Box<ast::Arg>>, TextSize)) -> ast::Arguments {
+fn __action1371<
+>(
+    __0: (TextSize, Option<Box<ast::Arg>>, TextSize),
+) -> ast::Arguments
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action848(__0, __temp0)
+    __action848(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1372(
+fn __action1372<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Arguments>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action861(__0, __1, __2, __temp0)
+    __action861(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1373(__0: (TextSize, token::Tok, TextSize)) -> ast::Stmt {
+fn __action1373<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> ast::Stmt
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action862(__0, __temp0)
+    __action862(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1374(
+fn __action1374<
+>(
     __0: (TextSize, ast::Pattern, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action863(__0, __1, __temp0)
+    __action863(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1375(
+fn __action1375<
+>(
     __0: (TextSize, Vec<ast::Pattern>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action864(__0, __1, __temp0)
+    __action864(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1376(__0: (TextSize, Vec<ast::Pattern>, TextSize)) -> ast::Pattern {
+fn __action1376<
+>(
+    __0: (TextSize, Vec<ast::Pattern>, TextSize),
+) -> ast::Pattern
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action865(__0, __temp0)
+    __action865(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1377(
+fn __action1377<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action866(__0, __1, __2, __temp0)
+    __action866(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1378(
+fn __action1378<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action867(__0, __1, __2, __temp0)
+    __action867(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1379(__0: (TextSize, token::Tok, TextSize)) -> ast::Stmt {
+fn __action1379<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> ast::Stmt
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action868(__0, __temp0)
+    __action868(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1380(
+fn __action1380<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1093(__0, __1, __2, __3, __temp0)
+    __action1093(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1381(
+fn __action1381<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1094(__0, __1, __temp0)
+    __action1094(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1382(
+fn __action1382<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Pattern, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action870(__0, __1, __2, __temp0)
+    __action870(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1383(
+fn __action1383<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action871(__0, __1, __temp0)
+    __action871(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1384(
+fn __action1384<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Pattern, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action872(__0, __1, __2, __3, __temp0)
+    __action872(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1385(
+fn __action1385<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     __2: (TextSize, ast::Pattern, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action873(__0, __1, __2, __3, __4, __temp0)
+    __action873(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1386(
+fn __action1386<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     __2: (TextSize, ast::Pattern, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action874(__0, __1, __2, __3, __temp0)
+    __action874(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1387(
+fn __action1387<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Pattern>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action875(__0, __1, __2, __temp0)
+    __action875(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1388(
+fn __action1388<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action876(__0, __1, __2, __temp0)
+    __action876(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1389(
+fn __action1389<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action877(__0, __1, __2, __temp0)
+    __action877(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1390(
+fn __action1390<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Expr, TextSize),
     __5: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
-) -> ast::Comprehension {
+) -> ast::Comprehension
+{
     let __start0 = __5.2;
     let __end0 = __5.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action878(__0, __1, __2, __3, __4, __5, __temp0)
+    __action878(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1391(
+fn __action1391<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
-) -> ast::Comprehension {
+) -> ast::Comprehension
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action879(__0, __1, __2, __3, __4, __temp0)
+    __action879(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1392(
+fn __action1392<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action881(__0, __1, __temp0)
+    __action881(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1393(
+fn __action1393<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Identifier, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action882(__0, __1, __temp0)
+    __action882(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1394(
+fn __action1394<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Arg {
+) -> ast::Arg
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1058(__0, __1, __2, __temp0)
+    __action1058(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1395(__0: (TextSize, ast::Identifier, TextSize)) -> ast::Arg {
+fn __action1395<
+>(
+    __0: (TextSize, ast::Identifier, TextSize),
+) -> ast::Arg
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1059(__0, __temp0)
+    __action1059(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1396(__0: (TextSize, ast::Identifier, TextSize)) -> ast::Arg {
+fn __action1396<
+>(
+    __0: (TextSize, ast::Identifier, TextSize),
+) -> ast::Arg
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action884(__0, __temp0)
+    __action884(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1397(
+fn __action1397<
+>(
     __0: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __3: (TextSize, core::option::Option<Option<ast::Expr>>, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action885(__0, __1, __2, __3, __temp0)
+    __action885(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1398(__0: (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action1398<
+>(
+    __0: (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action886(__0, __temp0)
+    __action886(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1399(
+fn __action1399<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action887(__0, __1, __temp0)
+    __action887(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1400(
+fn __action1400<
+>(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action888(__0, __1, __temp0)
+    __action888(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1401(__0: (TextSize, Vec<ast::Expr>, TextSize)) -> ast::Expr {
+fn __action1401<
+>(
+    __0: (TextSize, Vec<ast::Expr>, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action889(__0, __temp0)
+    __action889(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1402(
+fn __action1402<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action890(__0, __1, __2, __temp0)
+    __action890(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1403(
+fn __action1403<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action891(__0, __1, __2, __temp0)
+    __action891(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1404(
+fn __action1404<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action892(__0, __1, __2, __3, __4, __temp0)
+    __action892(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1405(
+fn __action1405<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action893(__0, __1, __2, __3, __4, __temp0)
+    __action893(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1406(
+fn __action1406<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Suite, TextSize),
-) -> ast::Mod {
+) -> ast::Mod
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action894(__0, __1, __temp0)
+    __action894(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1407(
+fn __action1407<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Suite, TextSize),
-) -> ast::Mod {
+) -> ast::Mod
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action895(__0, __1, __temp0)
+    __action895(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1408(
+fn __action1408<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Mod {
+) -> ast::Mod
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1062(__0, __1, __temp0)
+    __action1062(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1409(
+fn __action1409<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<token::Tok>, TextSize),
-) -> ast::Mod {
+) -> ast::Mod
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1063(__0, __1, __2, __temp0)
+    __action1063(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1410(
+fn __action1410<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -48003,16 +56629,33 @@ fn __action1410(
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, token::Tok, TextSize),
     __9: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __9.2;
     let __end0 = __9.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1084(__0, __1, __2, __3, __4, __5, __6, __7, __8, __9, __temp0)
+    __action1084(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+        __9,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1411(
+fn __action1411<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -48020,16 +56663,30 @@ fn __action1411(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1085(__0, __1, __2, __3, __4, __5, __6, __temp0)
+    __action1085(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1412(
+fn __action1412<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -48037,30 +56694,55 @@ fn __action1412(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1086(__0, __1, __2, __3, __4, __5, __6, __temp0)
+    __action1086(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1413(
+fn __action1413<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ExceptHandler>, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1087(__0, __1, __2, __3, __temp0)
+    __action1087(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1414(
+fn __action1414<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -48071,16 +56753,33 @@ fn __action1414(
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, token::Tok, TextSize),
     __9: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __9.2;
     let __end0 = __9.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1088(__0, __1, __2, __3, __4, __5, __6, __7, __8, __9, __temp0)
+    __action1088(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+        __9,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1415(
+fn __action1415<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -48088,16 +56787,30 @@ fn __action1415(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1089(__0, __1, __2, __3, __4, __5, __6, __temp0)
+    __action1089(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1416(
+fn __action1416<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
@@ -48105,268 +56818,485 @@ fn __action1416(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __6.2;
     let __end0 = __6.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1090(__0, __1, __2, __3, __4, __5, __6, __temp0)
+    __action1090(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1417(
+fn __action1417<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ExceptHandler>, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1091(__0, __1, __2, __3, __temp0)
+    __action1091(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1418(
+fn __action1418<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::ArgWithDefault {
+) -> ast::ArgWithDefault
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1055(__0, __1, __2, __temp0)
+    __action1055(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1419(__0: (TextSize, ast::Identifier, TextSize)) -> ast::ArgWithDefault {
+fn __action1419<
+>(
+    __0: (TextSize, ast::Identifier, TextSize),
+) -> ast::ArgWithDefault
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1056(__0, __temp0)
+    __action1056(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1420(__0: (TextSize, ast::Identifier, TextSize)) -> ast::ArgWithDefault {
+fn __action1420<
+>(
+    __0: (TextSize, ast::Identifier, TextSize),
+) -> ast::ArgWithDefault
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action901(__0, __temp0)
+    __action901(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1421(__0: (TextSize, ast::Expr, TextSize)) -> ast::Pattern {
+fn __action1421<
+>(
+    __0: (TextSize, ast::Expr, TextSize),
+) -> ast::Pattern
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action902(__0, __temp0)
+    __action902(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1422(__0: (TextSize, ast::Expr, TextSize)) -> ast::WithItem {
+fn __action1422<
+>(
+    __0: (TextSize, ast::Expr, TextSize),
+) -> ast::WithItem
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action904(__0, __temp0)
+    __action904(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1423(
+fn __action1423<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::WithItem {
+) -> ast::WithItem
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action905(__0, __1, __2, __temp0)
+    __action905(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1424(
+fn __action1424<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::WithItem {
+) -> ast::WithItem
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action906(__0, __1, __2, __temp0)
+    __action906(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1425(__0: (TextSize, ast::Expr, TextSize)) -> ast::WithItem {
+fn __action1425<
+>(
+    __0: (TextSize, ast::Expr, TextSize),
+) -> ast::WithItem
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action907(__0, __temp0)
+    __action907(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1426(
+fn __action1426<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::WithItem {
+) -> ast::WithItem
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action908(__0, __1, __2, __temp0)
+    __action908(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1427(__0: (TextSize, Vec<ast::Expr>, TextSize)) -> Vec<ast::WithItem> {
+fn __action1427<
+>(
+    __0: (TextSize, Vec<ast::Expr>, TextSize),
+) -> Vec<ast::WithItem>
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action909(__0, __temp0)
+    __action909(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1428(
+fn __action1428<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action912(__0, __1, __2, __temp0)
+    __action912(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1429(
+fn __action1429<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action913(__0, __1, __2, __temp0)
+    __action913(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1430(
+fn __action1430<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, core::option::Option<ast::Expr>, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.2;
     let __end0 = __1.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action914(__0, __1, __temp0)
+    __action914(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1431(
+fn __action1431<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action372(&__start0, &__end0);
+    let __temp0 = __action372(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action915(__0, __1, __2, __temp0)
+    __action915(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1432(
+fn __action1432<
+>(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action1427(__0);
+    let __temp0 = __action1427(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action289(__temp0, __1)
+    __action289(
+        __temp0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1433(
+fn __action1433<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action1427(__1);
+    let __temp0 = __action1427(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action625(__0, __temp0, __2, __3)
+    __action625(
+        __0,
+        __temp0,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1434(
+fn __action1434<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action1427(__1);
+    let __temp0 = __action1427(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action626(__0, __temp0, __2)
+    __action626(
+        __0,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1435(
+fn __action1435<
+>(
     __0: (TextSize, Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> core::option::Option<Vec<ast::WithItem>> {
+) -> core::option::Option<Vec<ast::WithItem>>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action1432(__0, __1);
+    let __temp0 = __action1432(
+        __0,
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action287(__temp0)
+    __action287(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1436(
+fn __action1436<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::WithItem, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1435(__1, __2);
+    let __temp0 = __action1435(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1041(__0, __temp0, __3, __4, __5)
+    __action1041(
+        __0,
+        __temp0,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1437(
+fn __action1437<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::WithItem, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action288(&__start0, &__end0);
+    let __temp0 = __action288(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1041(__0, __temp0, __1, __2, __3)
+    __action1041(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1438(
+fn __action1438<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -48374,601 +57304,889 @@ fn __action1438(
     __4: (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1435(__1, __2);
+    let __temp0 = __action1435(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1042(__0, __temp0, __3, __4, __5, __6)
+    __action1042(
+        __0,
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1439(
+fn __action1439<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::WithItem, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action288(&__start0, &__end0);
+    let __temp0 = __action288(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1042(__0, __temp0, __1, __2, __3, __4)
+    __action1042(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1440(
+fn __action1440<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::WithItem, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1435(__1, __2);
+    let __temp0 = __action1435(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1043(__0, __temp0, __3, __4)
+    __action1043(
+        __0,
+        __temp0,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1441(
+fn __action1441<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::WithItem, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action288(&__start0, &__end0);
+    let __temp0 = __action288(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1043(__0, __temp0, __1, __2)
+    __action1043(
+        __0,
+        __temp0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1442(
+fn __action1442<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::WithItem, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1435(__1, __2);
+    let __temp0 = __action1435(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1044(__0, __temp0, __3, __4, __5)
+    __action1044(
+        __0,
+        __temp0,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1443(
+fn __action1443<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::WithItem, TextSize),
     __2: (TextSize, alloc::vec::Vec<ast::WithItem>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Vec<ast::WithItem> {
+) -> Vec<ast::WithItem>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action288(&__start0, &__end0);
+    let __temp0 = __action288(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1044(__0, __temp0, __1, __2, __3)
+    __action1044(
+        __0,
+        __temp0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1444(
+fn __action1444<
+>(
     __0: (TextSize, (String, StringKind, bool), TextSize),
-) -> alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)> {
+) -> alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action1150(__0);
+    let __temp0 = __action1150(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action314(__temp0)
+    __action314(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1445(
-    __0: (
-        TextSize,
-        alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>,
-        TextSize,
-    ),
+fn __action1445<
+>(
+    __0: (TextSize, alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>, TextSize),
     __1: (TextSize, (String, StringKind, bool), TextSize),
-) -> alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)> {
+) -> alloc::vec::Vec<(TextSize, (String, StringKind, bool), TextSize)>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action1150(__1);
+    let __temp0 = __action1150(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action315(__0, __temp0)
+    __action315(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1446(
+fn __action1446<
+>(
     __0: (TextSize, ast::CmpOp, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<(ast::CmpOp, ast::Expr)> {
+) -> alloc::vec::Vec<(ast::CmpOp, ast::Expr)>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action473(__0, __1);
+    let __temp0 = __action473(
+        __0,
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action471(__temp0)
+    __action471(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1447(
+fn __action1447<
+>(
     __0: (TextSize, alloc::vec::Vec<(ast::CmpOp, ast::Expr)>, TextSize),
     __1: (TextSize, ast::CmpOp, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> alloc::vec::Vec<(ast::CmpOp, ast::Expr)> {
+) -> alloc::vec::Vec<(ast::CmpOp, ast::Expr)>
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action473(__1, __2);
+    let __temp0 = __action473(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action472(__0, __temp0)
+    __action472(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1448(__0: (TextSize, ast::Expr, TextSize)) -> core::option::Option<ast::Expr> {
+fn __action1448<
+>(
+    __0: (TextSize, ast::Expr, TextSize),
+) -> core::option::Option<ast::Expr>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action327(__0);
+    let __temp0 = __action327(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action325(__temp0)
+    __action325(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1449(
+fn __action1449<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Pattern, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Suite, TextSize),
-) -> ast::MatchCase {
+) -> ast::MatchCase
+{
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action1448(__2);
+    let __temp0 = __action1448(
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action818(__0, __1, __temp0, __3, __4)
+    __action818(
+        __0,
+        __1,
+        __temp0,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1450(
+fn __action1450<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Pattern, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-) -> ast::MatchCase {
+) -> ast::MatchCase
+{
     let __start0 = __1.2;
     let __end0 = __2.0;
-    let __temp0 = __action326(&__start0, &__end0);
+    let __temp0 = __action326(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action818(__0, __1, __temp0, __2, __3)
+    __action818(
+        __0,
+        __1,
+        __temp0,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1451(__0: (TextSize, ast::Arguments, TextSize)) -> core::option::Option<ast::Arguments> {
+fn __action1451<
+>(
+    __0: (TextSize, ast::Arguments, TextSize),
+) -> core::option::Option<ast::Arguments>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action265(__0);
+    let __temp0 = __action265(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action263(__temp0)
+    __action263(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1452(
+fn __action1452<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arguments, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action1451(__1);
+    let __temp0 = __action1451(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1372(__0, __temp0, __2)
+    __action1372(
+        __0,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1453(
+fn __action1453<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action264(&__start0, &__end0);
+    let __temp0 = __action264(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1372(__0, __temp0, __1)
+    __action1372(
+        __0,
+        __temp0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1454(__0: (TextSize, ast::Expr, TextSize)) -> ast::Stmt {
+fn __action1454<
+>(
+    __0: (TextSize, ast::Expr, TextSize),
+) -> ast::Stmt
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action362(&__start0, &__end0);
+    let __temp0 = __action362(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1241(__0, __temp0)
+    __action1241(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1455(
+fn __action1455<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action363(__1);
+    let __temp0 = __action363(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1241(__0, __temp0)
+    __action1241(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1456(
+fn __action1456<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action357(__3);
+    let __temp0 = __action357(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1243(__0, __1, __2, __temp0)
+    __action1243(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1457(
+fn __action1457<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action358(&__start0, &__end0);
+    let __temp0 = __action358(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1243(__0, __1, __2, __temp0)
+    __action1243(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1458(
-    __0: (
-        TextSize,
-        (
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        ),
-        TextSize,
-    ),
-) -> Vec<(
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-)> {
+fn __action1458<
+>(
+    __0: (TextSize, (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr), TextSize),
+) -> Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action421(__0);
+    let __temp0 = __action421(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1105(__temp0)
+    __action1105(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1459(
+fn __action1459<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> Vec<(
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-)> {
+) -> Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
+{
     let __start0 = *__lookbehind;
     let __end0 = *__lookahead;
-    let __temp0 = __action422(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1105(__temp0)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1460(
-    __0: (
-        TextSize,
-        alloc::vec::Vec<(
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        )>,
-        TextSize,
-    ),
-    __1: (
-        TextSize,
-        (
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        ),
-        TextSize,
-    ),
-) -> Vec<(
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-)> {
+    let __temp0 = __action422(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1105(
+        __temp0,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1460<
+>(
+    __0: (TextSize, alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
+    __1: (TextSize, (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr), TextSize),
+) -> Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action421(__1);
+    let __temp0 = __action421(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1106(__0, __temp0)
+    __action1106(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1461(
-    __0: (
-        TextSize,
-        alloc::vec::Vec<(
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        )>,
-        TextSize,
-    ),
-) -> Vec<(
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-)> {
+fn __action1461<
+>(
+    __0: (TextSize, alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
+) -> Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action422(&__start0, &__end0);
+    let __temp0 = __action422(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1106(__0, __temp0)
+    __action1106(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1462(
-    __0: (
-        TextSize,
-        (
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        ),
-        TextSize,
-    ),
-) -> Result<ArgumentList, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+fn __action1462<
+>(
+    __0: (TextSize, (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr), TextSize),
+) -> Result<ArgumentList,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action1458(__0);
+    let __temp0 = __action1458(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action216(__temp0)
+    __action216(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1463(
+fn __action1463<
+>(
     __lookbehind: &TextSize,
     __lookahead: &TextSize,
-) -> Result<ArgumentList, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ArgumentList,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = *__lookbehind;
     let __end0 = *__lookahead;
-    let __temp0 = __action1459(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action216(__temp0)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1464(
-    __0: (
-        TextSize,
-        alloc::vec::Vec<(
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        )>,
-        TextSize,
-    ),
-    __1: (
-        TextSize,
-        (
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        ),
-        TextSize,
-    ),
-) -> Result<ArgumentList, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+    let __temp0 = __action1459(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action216(
+        __temp0,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1464<
+>(
+    __0: (TextSize, alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
+    __1: (TextSize, (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr), TextSize),
+) -> Result<ArgumentList,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __1.2;
-    let __temp0 = __action1460(__0, __1);
+    let __temp0 = __action1460(
+        __0,
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action216(__temp0)
+    __action216(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1465(
-    __0: (
-        TextSize,
-        alloc::vec::Vec<(
-            Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-            ast::Expr,
-        )>,
-        TextSize,
-    ),
-) -> Result<ArgumentList, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+fn __action1465<
+>(
+    __0: (TextSize, alloc::vec::Vec<(Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)>, TextSize),
+) -> Result<ArgumentList,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action1461(__0);
+    let __temp0 = __action1461(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action216(__temp0)
+    __action216(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1466(__0: (TextSize, ast::Pattern, TextSize)) -> Vec<ast::Pattern> {
+fn __action1466<
+>(
+    __0: (TextSize, ast::Pattern, TextSize),
+) -> Vec<ast::Pattern>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action383(__0);
+    let __temp0 = __action383(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1128(__temp0)
+    __action1128(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1467(__lookbehind: &TextSize, __lookahead: &TextSize) -> Vec<ast::Pattern> {
+fn __action1467<
+>(
+    __lookbehind: &TextSize,
+    __lookahead: &TextSize,
+) -> Vec<ast::Pattern>
+{
     let __start0 = *__lookbehind;
     let __end0 = *__lookahead;
-    let __temp0 = __action384(&__start0, &__end0);
+    let __temp0 = __action384(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1128(__temp0)
+    __action1128(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1468(
+fn __action1468<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     __1: (TextSize, ast::Pattern, TextSize),
-) -> Vec<ast::Pattern> {
+) -> Vec<ast::Pattern>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action383(__1);
+    let __temp0 = __action383(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1129(__0, __temp0)
+    __action1129(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1469(__0: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize)) -> Vec<ast::Pattern> {
+fn __action1469<
+>(
+    __0: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
+) -> Vec<ast::Pattern>
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action384(&__start0, &__end0);
+    let __temp0 = __action384(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1129(__0, __temp0)
+    __action1129(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1470(
+fn __action1470<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Pattern, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action1466(__1);
+    let __temp0 = __action1466(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1387(__0, __temp0, __2)
+    __action1387(
+        __0,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1471(
+fn __action1471<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action1467(&__start0, &__end0);
+    let __temp0 = __action1467(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1387(__0, __temp0, __1)
+    __action1387(
+        __0,
+        __temp0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1472(
+fn __action1472<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     __2: (TextSize, ast::Pattern, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __1.0;
     let __end0 = __2.2;
-    let __temp0 = __action1468(__1, __2);
+    let __temp0 = __action1468(
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1387(__0, __temp0, __3)
+    __action1387(
+        __0,
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1473(
+fn __action1473<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Pattern>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Pattern {
+) -> ast::Pattern
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action1469(__1);
+    let __temp0 = __action1469(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1387(__0, __temp0, __2)
+    __action1387(
+        __0,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1474(
+fn __action1474<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, Vec<ast::Comprehension>, TextSize),
-) -> (
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-) {
+) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action225(__1);
+    let __temp0 = __action225(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1250(__0, __temp0)
+    __action1250(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1475(
+fn __action1475<
+>(
     __0: (TextSize, ast::Expr, TextSize),
-) -> (
-    Option<(TextSize, TextSize, Option<ast::Identifier>)>,
-    ast::Expr,
-) {
+) -> (Option<(TextSize, TextSize, Option<ast::Identifier>)>, ast::Expr)
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action226(&__start0, &__end0);
+    let __temp0 = __action226(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1250(__0, __temp0)
+    __action1250(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1476(
+fn __action1476<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Expr, TextSize),
-) -> ast::Comprehension {
+) -> ast::Comprehension
+{
     let __start0 = __4.2;
     let __end0 = __4.2;
-    let __temp0 = __action228(&__start0, &__end0);
+    let __temp0 = __action228(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1390(__0, __1, __2, __3, __4, __temp0)
+    __action1390(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1477(
+fn __action1477<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Expr, TextSize),
     __5: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
-) -> ast::Comprehension {
+) -> ast::Comprehension
+{
     let __start0 = __5.0;
     let __end0 = __5.2;
-    let __temp0 = __action229(__5);
+    let __temp0 = __action229(
+        __5,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1390(__0, __1, __2, __3, __4, __temp0)
+    __action1390(
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1478(
+fn __action1478<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
-) -> ast::Comprehension {
+) -> ast::Comprehension
+{
     let __start0 = __3.2;
     let __end0 = __3.2;
-    let __temp0 = __action228(&__start0, &__end0);
+    let __temp0 = __action228(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1391(__0, __1, __2, __3, __temp0)
+    __action1391(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1479(
+fn __action1479<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
-) -> ast::Comprehension {
+) -> ast::Comprehension
+{
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action229(__4);
+    let __temp0 = __action229(
+        __4,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1391(__0, __1, __2, __3, __temp0)
+    __action1391(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1480(
+fn __action1480<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Identifier, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -48976,16 +58194,30 @@ fn __action1480(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action273(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action740(__temp0, __0, __1, __2, __3, __4, __5, __6)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1481(
+    let __temp0 = __action273(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action740(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1481<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
@@ -48994,45 +58226,79 @@ fn __action1481(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action274(__0);
+    let __temp0 = __action274(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action740(__temp0, __1, __2, __3, __4, __5, __6, __7)
+    __action740(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1482(
+fn __action1482<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Identifier, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action273(&__start0, &__end0);
+    let __temp0 = __action273(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action741(__temp0, __0, __1, __2, __3)
+    __action741(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1483(
+fn __action1483<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action274(__0);
+    let __temp0 = __action274(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action741(__temp0, __1, __2, __3, __4)
+    __action741(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1484(
+fn __action1484<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
@@ -49041,16 +58307,31 @@ fn __action1484(
     __5: (TextSize, ast::Expr, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action273(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1046(__temp0, __0, __1, __2, __3, __4, __5, __6, __7)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1485(
+    let __temp0 = __action273(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1046(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1485<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49060,32 +58341,59 @@ fn __action1485(
     __6: (TextSize, ast::Expr, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action274(__0);
+    let __temp0 = __action274(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1046(__temp0, __1, __2, __3, __4, __5, __6, __7, __8)
+    __action1046(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1486(
+fn __action1486<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, ast::Arguments, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action273(&__start0, &__end0);
+    let __temp0 = __action273(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1047(__temp0, __0, __1, __2, __3, __4, __5)
+    __action1047(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1487(
+fn __action1487<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49093,16 +58401,28 @@ fn __action1487(
     __4: (TextSize, ast::Arguments, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action274(__0);
+    let __temp0 = __action274(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1047(__temp0, __1, __2, __3, __4, __5, __6)
+    __action1047(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1488(
+fn __action1488<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Identifier, TextSize),
     __2: (TextSize, ast::Arguments, TextSize),
@@ -49110,16 +58430,30 @@ fn __action1488(
     __4: (TextSize, ast::Expr, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action273(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1048(__temp0, __0, __1, __2, __3, __4, __5, __6)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1489(
+    let __temp0 = __action273(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1048(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1489<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
@@ -49128,291 +58462,495 @@ fn __action1489(
     __5: (TextSize, ast::Expr, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action274(__0);
+    let __temp0 = __action274(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1048(__temp0, __1, __2, __3, __4, __5, __6, __7)
+    __action1048(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1490(
+fn __action1490<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Identifier, TextSize),
     __2: (TextSize, ast::Arguments, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action273(&__start0, &__end0);
+    let __temp0 = __action273(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1049(__temp0, __0, __1, __2, __3, __4)
+    __action1049(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1491(
+fn __action1491<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, ast::Arguments, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action274(__0);
+    let __temp0 = __action274(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1049(__temp0, __1, __2, __3, __4, __5)
+    __action1049(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1492(
+fn __action1492<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<(Option<Box<ast::Expr>>, ast::Expr)>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action523(__1);
+    let __temp0 = __action523(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1178(__0, __temp0, __2)
+    __action1178(
+        __0,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1493(
+fn __action1493<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action524(&__start0, &__end0);
+    let __temp0 = __action524(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1178(__0, __temp0, __1)
+    __action1178(
+        __0,
+        __temp0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1494(
+fn __action1494<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<(Option<Box<ast::Expr>>, ast::Expr)>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action523(__1);
+    let __temp0 = __action523(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1201(__0, __temp0, __2)
+    __action1201(
+        __0,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1495(
+fn __action1495<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action524(&__start0, &__end0);
+    let __temp0 = __action524(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1201(__0, __temp0, __1)
+    __action1201(
+        __0,
+        __temp0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1496(
+fn __action1496<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arg, TextSize),
-) -> Option<Box<ast::Arg>> {
+) -> Option<Box<ast::Arg>>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action457(__1);
+    let __temp0 = __action457(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action395(__0, __temp0)
+    __action395(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1497(__0: (TextSize, token::Tok, TextSize)) -> Option<Box<ast::Arg>> {
+fn __action1497<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> Option<Box<ast::Arg>>
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action458(&__start0, &__end0);
+    let __temp0 = __action458(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action395(__0, __temp0)
+    __action395(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1498(
+fn __action1498<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> Vec<ast::Alias> {
+) -> Vec<ast::Alias>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action1259(__0, __1, __2);
+    let __temp0 = __action1259(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action349(__temp0)
+    __action349(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1499(__0: (TextSize, ast::Identifier, TextSize)) -> Vec<ast::Alias> {
+fn __action1499<
+>(
+    __0: (TextSize, ast::Identifier, TextSize),
+) -> Vec<ast::Alias>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action1260(__0);
+    let __temp0 = __action1260(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action349(__temp0)
+    __action349(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1500(
+fn __action1500<
+>(
     __0: (TextSize, Vec<ast::Alias>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Identifier, TextSize),
-) -> Vec<ast::Alias> {
+) -> Vec<ast::Alias>
+{
     let __start0 = __2.0;
     let __end0 = __4.2;
-    let __temp0 = __action1259(__2, __3, __4);
+    let __temp0 = __action1259(
+        __2,
+        __3,
+        __4,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action350(__0, __1, __temp0)
+    __action350(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1501(
+fn __action1501<
+>(
     __0: (TextSize, Vec<ast::Alias>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> Vec<ast::Alias> {
+) -> Vec<ast::Alias>
+{
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action1260(__2);
+    let __temp0 = __action1260(
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action350(__0, __1, __temp0)
+    __action350(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1502(
+fn __action1502<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> Vec<ast::Alias> {
+) -> Vec<ast::Alias>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action1261(__0, __1, __2);
+    let __temp0 = __action1261(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action342(__temp0)
+    __action342(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1503(__0: (TextSize, ast::Identifier, TextSize)) -> Vec<ast::Alias> {
+fn __action1503<
+>(
+    __0: (TextSize, ast::Identifier, TextSize),
+) -> Vec<ast::Alias>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action1262(__0);
+    let __temp0 = __action1262(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action342(__temp0)
+    __action342(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1504(
+fn __action1504<
+>(
     __0: (TextSize, Vec<ast::Alias>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, ast::Identifier, TextSize),
-) -> Vec<ast::Alias> {
+) -> Vec<ast::Alias>
+{
     let __start0 = __2.0;
     let __end0 = __4.2;
-    let __temp0 = __action1261(__2, __3, __4);
+    let __temp0 = __action1261(
+        __2,
+        __3,
+        __4,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action343(__0, __1, __temp0)
+    __action343(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1505(
+fn __action1505<
+>(
     __0: (TextSize, Vec<ast::Alias>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Identifier, TextSize),
-) -> Vec<ast::Alias> {
+) -> Vec<ast::Alias>
+{
     let __start0 = __2.0;
     let __end0 = __2.2;
-    let __temp0 = __action1262(__2);
+    let __temp0 = __action1262(
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action343(__0, __1, __temp0)
+    __action343(
+        __0,
+        __1,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1506(
+fn __action1506<
+>(
     __0: (TextSize, ast::Identifier, TextSize),
-) -> (Option<ast::Int>, Option<ast::Identifier>) {
+) -> (Option<ast::Int>, Option<ast::Identifier>)
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
-    let __temp0 = __action347(&__start0, &__end0);
+    let __temp0 = __action347(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action59(__temp0, __0)
+    __action59(
+        __temp0,
+        __0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1507(
+fn __action1507<
+>(
     __0: (TextSize, alloc::vec::Vec<ast::Int>, TextSize),
     __1: (TextSize, ast::Identifier, TextSize),
-) -> (Option<ast::Int>, Option<ast::Identifier>) {
+) -> (Option<ast::Int>, Option<ast::Identifier>)
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action348(__0);
+    let __temp0 = __action348(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action59(__temp0, __1)
+    __action59(
+        __temp0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1508(
+fn __action1508<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action531(__1);
+    let __temp0 = __action531(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1163(__0, __temp0, __2)
+    __action1163(
+        __0,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1509(
+fn __action1509<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action532(&__start0, &__end0);
+    let __temp0 = __action532(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1163(__0, __temp0, __1)
+    __action1163(
+        __0,
+        __temp0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1510(
+fn __action1510<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Vec<ast::Expr>, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action531(__1);
+    let __temp0 = __action531(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1188(__0, __temp0, __2)
+    __action1188(
+        __0,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1511(
+fn __action1511<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action532(&__start0, &__end0);
+    let __temp0 = __action532(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1188(__0, __temp0, __1)
+    __action1188(
+        __0,
+        __temp0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1512(
+fn __action1512<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49420,16 +58958,28 @@ fn __action1512(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(__0);
+    let __temp0 = __action400(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1296(__temp0, __1, __2, __3, __4, __5, __6)
+    __action1296(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1513(
+fn __action1513<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49439,16 +58989,30 @@ fn __action1513(
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __8: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(__0, __1, __2);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1296(__temp0, __3, __4, __5, __6, __7, __8)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1514(
+    let __temp0 = __action660(
+        __0,
+        __1,
+        __2,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1296(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1514<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49459,32 +59023,58 @@ fn __action1514(
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __9: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(__0, __1, __2, __3);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1296(__temp0, __4, __5, __6, __7, __8, __9)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1515(
+    let __temp0 = __action661(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1296(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+        __9,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1515<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(__0);
+    let __temp0 = __action400(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1297(__temp0, __1, __2, __3, __4, __5)
+    __action1297(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1516(
+fn __action1516<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49493,16 +59083,29 @@ fn __action1516(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(__0, __1, __2);
+    let __temp0 = __action660(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1297(__temp0, __3, __4, __5, __6, __7)
+    __action1297(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1517(
+fn __action1517<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49512,16 +59115,30 @@ fn __action1517(
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __8: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(__0, __1, __2, __3);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1297(__temp0, __4, __5, __6, __7, __8)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1518(
+    let __temp0 = __action661(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1297(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1518<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49530,16 +59147,29 @@ fn __action1518(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(__0);
+    let __temp0 = __action400(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1298(__temp0, __1, __2, __3, __4, __5, __6, __7)
+    __action1298(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1519(
+fn __action1519<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49550,16 +59180,31 @@ fn __action1519(
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __9: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(__0, __1, __2);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1298(__temp0, __3, __4, __5, __6, __7, __8, __9)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1520(
+    let __temp0 = __action660(
+        __0,
+        __1,
+        __2,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1298(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+        __9,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1520<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49571,16 +59216,32 @@ fn __action1520(
     __8: (TextSize, token::Tok, TextSize),
     __9: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __10: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(__0, __1, __2, __3);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1298(__temp0, __4, __5, __6, __7, __8, __9, __10)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1521(
+    let __temp0 = __action661(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1298(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+        __9,
+        __10,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1521<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49588,16 +59249,28 @@ fn __action1521(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(__0);
+    let __temp0 = __action400(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1299(__temp0, __1, __2, __3, __4, __5, __6)
+    __action1299(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1522(
+fn __action1522<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49607,16 +59280,30 @@ fn __action1522(
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __8: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(__0, __1, __2);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1299(__temp0, __3, __4, __5, __6, __7, __8)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1523(
+    let __temp0 = __action660(
+        __0,
+        __1,
+        __2,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1299(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1523<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49627,31 +59314,56 @@ fn __action1523(
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __9: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(__0, __1, __2, __3);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1299(__temp0, __4, __5, __6, __7, __8, __9)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1524(
+    let __temp0 = __action661(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1299(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+        __9,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1524<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(__0);
+    let __temp0 = __action400(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1300(__temp0, __1, __2, __3, __4)
+    __action1300(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1525(
+fn __action1525<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49659,16 +59371,28 @@ fn __action1525(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Arg, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(__0, __1, __2);
+    let __temp0 = __action660(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1300(__temp0, __3, __4, __5, __6)
+    __action1300(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1526(
+fn __action1526<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49677,46 +59401,79 @@ fn __action1526(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Arg, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(__0, __1, __2, __3);
+    let __temp0 = __action661(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1300(__temp0, __4, __5, __6, __7)
+    __action1300(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1527(
+fn __action1527<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(__0);
+    let __temp0 = __action400(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1301(__temp0, __1, __2, __3)
+    __action1301(
+        __temp0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1528(
+fn __action1528<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(__0, __1, __2);
+    let __temp0 = __action660(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1301(__temp0, __3, __4, __5)
+    __action1301(
+        __temp0,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1529(
+fn __action1529<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49724,32 +59481,55 @@ fn __action1529(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(__0, __1, __2, __3);
+    let __temp0 = __action661(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1301(__temp0, __4, __5, __6)
+    __action1301(
+        __temp0,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1530(
+fn __action1530<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(__0);
+    let __temp0 = __action400(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1302(__temp0, __1, __2, __3, __4, __5)
+    __action1302(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1531(
+fn __action1531<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49758,16 +59538,29 @@ fn __action1531(
     __5: (TextSize, ast::Arg, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(__0, __1, __2);
+    let __temp0 = __action660(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1302(__temp0, __3, __4, __5, __6, __7)
+    __action1302(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1532(
+fn __action1532<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49777,31 +59570,55 @@ fn __action1532(
     __6: (TextSize, ast::Arg, TextSize),
     __7: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __8: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(__0, __1, __2, __3);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1302(__temp0, __4, __5, __6, __7, __8)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1533(
+    let __temp0 = __action661(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1302(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1533<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(__0);
+    let __temp0 = __action400(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1303(__temp0, __1, __2, __3, __4)
+    __action1303(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1534(
+fn __action1534<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49809,16 +59626,28 @@ fn __action1534(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(__0, __1, __2);
+    let __temp0 = __action660(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1303(__temp0, __3, __4, __5, __6)
+    __action1303(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1535(
+fn __action1535<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49827,73 +59656,123 @@ fn __action1535(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(__0, __1, __2, __3);
+    let __temp0 = __action661(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1303(__temp0, __4, __5, __6, __7)
+    __action1303(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1536(
+fn __action1536<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(__0);
+    let __temp0 = __action400(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1304(__temp0, __1)
+    __action1304(
+        __temp0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1537(
+fn __action1537<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(__0, __1, __2);
+    let __temp0 = __action660(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1304(__temp0, __3)
+    __action1304(
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1538(
+fn __action1538<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(__0, __1, __2, __3);
+    let __temp0 = __action661(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1304(__temp0, __4)
+    __action1304(
+        __temp0,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1539(
+fn __action1539<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(__0);
+    let __temp0 = __action400(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1305(__temp0, __1, __2, __3, __4, __5)
+    __action1305(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1540(
+fn __action1540<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49902,16 +59781,29 @@ fn __action1540(
     __5: (TextSize, ast::Arg, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(__0, __1, __2);
+    let __temp0 = __action660(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1305(__temp0, __3, __4, __5, __6, __7)
+    __action1305(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1541(
+fn __action1541<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49921,31 +59813,55 @@ fn __action1541(
     __6: (TextSize, ast::Arg, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(__0, __1, __2, __3);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1305(__temp0, __4, __5, __6, __7, __8)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1542(
+    let __temp0 = __action661(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1305(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1542<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(__0);
+    let __temp0 = __action400(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1306(__temp0, __1, __2, __3, __4)
+    __action1306(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1543(
+fn __action1543<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49953,16 +59869,28 @@ fn __action1543(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(__0, __1, __2);
+    let __temp0 = __action660(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1306(__temp0, __3, __4, __5, __6)
+    __action1306(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1544(
+fn __action1544<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49971,16 +59899,29 @@ fn __action1544(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(__0, __1, __2, __3);
+    let __temp0 = __action661(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1306(__temp0, __4, __5, __6, __7)
+    __action1306(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1545(
+fn __action1545<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -49988,16 +59929,28 @@ fn __action1545(
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(__0);
+    let __temp0 = __action400(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1307(__temp0, __1, __2, __3, __4, __5, __6)
+    __action1307(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1546(
+fn __action1546<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50007,16 +59960,30 @@ fn __action1546(
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(__0, __1, __2);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1307(__temp0, __3, __4, __5, __6, __7, __8)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1547(
+    let __temp0 = __action660(
+        __0,
+        __1,
+        __2,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1307(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1547<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50027,32 +59994,58 @@ fn __action1547(
     __7: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __8: (TextSize, token::Tok, TextSize),
     __9: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(__0, __1, __2, __3);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1307(__temp0, __4, __5, __6, __7, __8, __9)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1548(
+    let __temp0 = __action661(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1307(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+        __9,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1548<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(__0);
+    let __temp0 = __action400(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1308(__temp0, __1, __2, __3, __4, __5)
+    __action1308(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1549(
+fn __action1549<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50061,16 +60054,29 @@ fn __action1549(
     __5: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(__0, __1, __2);
+    let __temp0 = __action660(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1308(__temp0, __3, __4, __5, __6, __7)
+    __action1308(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1550(
+fn __action1550<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50080,46 +60086,80 @@ fn __action1550(
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(__0, __1, __2, __3);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1308(__temp0, __4, __5, __6, __7, __8)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1551(
+    let __temp0 = __action661(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1308(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1551<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(__0);
+    let __temp0 = __action400(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1309(__temp0, __1, __2, __3)
+    __action1309(
+        __temp0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1552(
+fn __action1552<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Arg, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(__0, __1, __2);
+    let __temp0 = __action660(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1309(__temp0, __3, __4, __5)
+    __action1309(
+        __temp0,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1553(
+fn __action1553<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50127,75 +60167,126 @@ fn __action1553(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Arg, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(__0, __1, __2, __3);
+    let __temp0 = __action661(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1309(__temp0, __4, __5, __6)
+    __action1309(
+        __temp0,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1554(
+fn __action1554<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(__0);
+    let __temp0 = __action400(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1310(__temp0, __1, __2)
+    __action1310(
+        __temp0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1555(
+fn __action1555<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(__0, __1, __2);
+    let __temp0 = __action660(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1310(__temp0, __3, __4)
+    __action1310(
+        __temp0,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1556(
+fn __action1556<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(__0, __1, __2, __3);
+    let __temp0 = __action661(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1310(__temp0, __4, __5)
+    __action1310(
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1557(
+fn __action1557<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(__0);
+    let __temp0 = __action400(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1311(__temp0, __1, __2, __3, __4)
+    __action1311(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1558(
+fn __action1558<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50203,16 +60294,28 @@ fn __action1558(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Arg, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(__0, __1, __2);
+    let __temp0 = __action660(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1311(__temp0, __3, __4, __5, __6)
+    __action1311(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1559(
+fn __action1559<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50221,46 +60324,79 @@ fn __action1559(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Arg, TextSize),
     __7: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(__0, __1, __2, __3);
+    let __temp0 = __action661(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1311(__temp0, __4, __5, __6, __7)
+    __action1311(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1560(
+fn __action1560<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(__0);
+    let __temp0 = __action400(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1312(__temp0, __1, __2, __3)
+    __action1312(
+        __temp0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1561(
+fn __action1561<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(__0, __1, __2);
+    let __temp0 = __action660(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1312(__temp0, __3, __4, __5)
+    __action1312(
+        __temp0,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1562(
+fn __action1562<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50268,84 +60404,139 @@ fn __action1562(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(__0, __1, __2, __3);
+    let __temp0 = __action661(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1312(__temp0, __4, __5, __6)
+    __action1312(
+        __temp0,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1563(
+fn __action1563<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(__0);
+    let __temp0 = __action400(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1313(__temp0)
+    __action1313(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1564(
+fn __action1564<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(__0, __1, __2);
+    let __temp0 = __action660(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1313(__temp0)
+    __action1313(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1565(
+fn __action1565<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(__0, __1, __2, __3);
+    let __temp0 = __action661(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1313(__temp0)
+    __action1313(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1566(
+fn __action1566<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(__0);
+    let __temp0 = __action400(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1314(__temp0, __1, __2, __3)
+    __action1314(
+        __temp0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1567(
+fn __action1567<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(__0, __1, __2);
+    let __temp0 = __action660(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1314(__temp0, __3, __4, __5)
+    __action1314(
+        __temp0,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1568(
+fn __action1568<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50353,60 +60544,101 @@ fn __action1568(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(__0, __1, __2, __3);
+    let __temp0 = __action661(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1314(__temp0, __4, __5, __6)
+    __action1314(
+        __temp0,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1569(
+fn __action1569<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action400(__0);
+    let __temp0 = __action400(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1315(__temp0, __1, __2)
+    __action1315(
+        __temp0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1570(
+fn __action1570<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action660(__0, __1, __2);
+    let __temp0 = __action660(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1315(__temp0, __3, __4)
+    __action1315(
+        __temp0,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1571(
+fn __action1571<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action661(__0, __1, __2, __3);
+    let __temp0 = __action661(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1315(__temp0, __4, __5)
+    __action1315(
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1572(
+fn __action1572<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50414,16 +60646,28 @@ fn __action1572(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(__0);
+    let __temp0 = __action408(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1334(__temp0, __1, __2, __3, __4, __5, __6)
+    __action1334(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1573(
+fn __action1573<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50433,16 +60677,30 @@ fn __action1573(
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __8: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(__0, __1, __2);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1334(__temp0, __3, __4, __5, __6, __7, __8)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1574(
+    let __temp0 = __action668(
+        __0,
+        __1,
+        __2,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1334(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1574<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50453,32 +60711,58 @@ fn __action1574(
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __9: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(__0, __1, __2, __3);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1334(__temp0, __4, __5, __6, __7, __8, __9)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1575(
+    let __temp0 = __action669(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1334(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+        __9,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1575<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(__0);
+    let __temp0 = __action408(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1335(__temp0, __1, __2, __3, __4, __5)
+    __action1335(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1576(
+fn __action1576<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50487,16 +60771,29 @@ fn __action1576(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(__0, __1, __2);
+    let __temp0 = __action668(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1335(__temp0, __3, __4, __5, __6, __7)
+    __action1335(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1577(
+fn __action1577<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50506,16 +60803,30 @@ fn __action1577(
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __8: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(__0, __1, __2, __3);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1335(__temp0, __4, __5, __6, __7, __8)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1578(
+    let __temp0 = __action669(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1335(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1578<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50524,16 +60835,29 @@ fn __action1578(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(__0);
+    let __temp0 = __action408(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1336(__temp0, __1, __2, __3, __4, __5, __6, __7)
+    __action1336(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1579(
+fn __action1579<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50544,16 +60868,31 @@ fn __action1579(
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __9: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(__0, __1, __2);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1336(__temp0, __3, __4, __5, __6, __7, __8, __9)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1580(
+    let __temp0 = __action668(
+        __0,
+        __1,
+        __2,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1336(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+        __9,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1580<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50565,16 +60904,32 @@ fn __action1580(
     __8: (TextSize, token::Tok, TextSize),
     __9: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __10: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(__0, __1, __2, __3);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1336(__temp0, __4, __5, __6, __7, __8, __9, __10)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1581(
+    let __temp0 = __action669(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1336(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+        __9,
+        __10,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1581<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50582,16 +60937,28 @@ fn __action1581(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(__0);
+    let __temp0 = __action408(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1337(__temp0, __1, __2, __3, __4, __5, __6)
+    __action1337(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1582(
+fn __action1582<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50601,16 +60968,30 @@ fn __action1582(
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __8: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(__0, __1, __2);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1337(__temp0, __3, __4, __5, __6, __7, __8)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1583(
+    let __temp0 = __action668(
+        __0,
+        __1,
+        __2,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1337(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1583<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50621,31 +61002,56 @@ fn __action1583(
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __9: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(__0, __1, __2, __3);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1337(__temp0, __4, __5, __6, __7, __8, __9)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1584(
+    let __temp0 = __action669(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1337(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+        __9,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1584<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(__0);
+    let __temp0 = __action408(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1338(__temp0, __1, __2, __3, __4)
+    __action1338(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1585(
+fn __action1585<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50653,16 +61059,28 @@ fn __action1585(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Arg, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(__0, __1, __2);
+    let __temp0 = __action668(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1338(__temp0, __3, __4, __5, __6)
+    __action1338(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1586(
+fn __action1586<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50671,46 +61089,79 @@ fn __action1586(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Arg, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(__0, __1, __2, __3);
+    let __temp0 = __action669(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1338(__temp0, __4, __5, __6, __7)
+    __action1338(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1587(
+fn __action1587<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(__0);
+    let __temp0 = __action408(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1339(__temp0, __1, __2, __3)
+    __action1339(
+        __temp0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1588(
+fn __action1588<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(__0, __1, __2);
+    let __temp0 = __action668(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1339(__temp0, __3, __4, __5)
+    __action1339(
+        __temp0,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1589(
+fn __action1589<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50718,32 +61169,55 @@ fn __action1589(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(__0, __1, __2, __3);
+    let __temp0 = __action669(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1339(__temp0, __4, __5, __6)
+    __action1339(
+        __temp0,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1590(
+fn __action1590<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(__0);
+    let __temp0 = __action408(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1340(__temp0, __1, __2, __3, __4, __5)
+    __action1340(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1591(
+fn __action1591<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50752,16 +61226,29 @@ fn __action1591(
     __5: (TextSize, ast::Arg, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(__0, __1, __2);
+    let __temp0 = __action668(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1340(__temp0, __3, __4, __5, __6, __7)
+    __action1340(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1592(
+fn __action1592<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50771,31 +61258,55 @@ fn __action1592(
     __6: (TextSize, ast::Arg, TextSize),
     __7: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __8: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(__0, __1, __2, __3);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1340(__temp0, __4, __5, __6, __7, __8)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1593(
+    let __temp0 = __action669(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1340(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1593<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(__0);
+    let __temp0 = __action408(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1341(__temp0, __1, __2, __3, __4)
+    __action1341(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1594(
+fn __action1594<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50803,16 +61314,28 @@ fn __action1594(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(__0, __1, __2);
+    let __temp0 = __action668(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1341(__temp0, __3, __4, __5, __6)
+    __action1341(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1595(
+fn __action1595<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50821,73 +61344,123 @@ fn __action1595(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(__0, __1, __2, __3);
+    let __temp0 = __action669(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1341(__temp0, __4, __5, __6, __7)
+    __action1341(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1596(
+fn __action1596<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(__0);
+    let __temp0 = __action408(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1342(__temp0, __1)
+    __action1342(
+        __temp0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1597(
+fn __action1597<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(__0, __1, __2);
+    let __temp0 = __action668(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1342(__temp0, __3)
+    __action1342(
+        __temp0,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1598(
+fn __action1598<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(__0, __1, __2, __3);
+    let __temp0 = __action669(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1342(__temp0, __4)
+    __action1342(
+        __temp0,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1599(
+fn __action1599<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(__0);
+    let __temp0 = __action408(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1343(__temp0, __1, __2, __3, __4, __5)
+    __action1343(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1600(
+fn __action1600<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50896,16 +61469,29 @@ fn __action1600(
     __5: (TextSize, ast::Arg, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(__0, __1, __2);
+    let __temp0 = __action668(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1343(__temp0, __3, __4, __5, __6, __7)
+    __action1343(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1601(
+fn __action1601<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50915,31 +61501,55 @@ fn __action1601(
     __6: (TextSize, ast::Arg, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(__0, __1, __2, __3);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1343(__temp0, __4, __5, __6, __7, __8)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1602(
+    let __temp0 = __action669(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1343(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1602<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(__0);
+    let __temp0 = __action408(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1344(__temp0, __1, __2, __3, __4)
+    __action1344(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1603(
+fn __action1603<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50947,16 +61557,28 @@ fn __action1603(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(__0, __1, __2);
+    let __temp0 = __action668(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1344(__temp0, __3, __4, __5, __6)
+    __action1344(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1604(
+fn __action1604<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50965,16 +61587,29 @@ fn __action1604(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(__0, __1, __2, __3);
+    let __temp0 = __action669(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1344(__temp0, __4, __5, __6, __7)
+    __action1344(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1605(
+fn __action1605<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -50982,16 +61617,28 @@ fn __action1605(
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(__0);
+    let __temp0 = __action408(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1345(__temp0, __1, __2, __3, __4, __5, __6)
+    __action1345(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1606(
+fn __action1606<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -51001,16 +61648,30 @@ fn __action1606(
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(__0, __1, __2);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1345(__temp0, __3, __4, __5, __6, __7, __8)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1607(
+    let __temp0 = __action668(
+        __0,
+        __1,
+        __2,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1345(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1607<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -51021,32 +61682,58 @@ fn __action1607(
     __7: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __8: (TextSize, token::Tok, TextSize),
     __9: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(__0, __1, __2, __3);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1345(__temp0, __4, __5, __6, __7, __8, __9)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1608(
+    let __temp0 = __action669(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1345(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+        __9,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1608<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(__0);
+    let __temp0 = __action408(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1346(__temp0, __1, __2, __3, __4, __5)
+    __action1346(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1609(
+fn __action1609<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -51055,16 +61742,29 @@ fn __action1609(
     __5: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(__0, __1, __2);
+    let __temp0 = __action668(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1346(__temp0, __3, __4, __5, __6, __7)
+    __action1346(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1610(
+fn __action1610<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -51074,46 +61774,80 @@ fn __action1610(
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(__0, __1, __2, __3);
-    let __temp0 = (__start0, __temp0, __end0);
-    __action1346(__temp0, __4, __5, __6, __7, __8)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn __action1611(
+    let __temp0 = __action669(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action1346(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+fn __action1611<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(__0);
+    let __temp0 = __action408(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1347(__temp0, __1, __2, __3)
+    __action1347(
+        __temp0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1612(
+fn __action1612<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Arg, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(__0, __1, __2);
+    let __temp0 = __action668(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1347(__temp0, __3, __4, __5)
+    __action1347(
+        __temp0,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1613(
+fn __action1613<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -51121,75 +61855,126 @@ fn __action1613(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Arg, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(__0, __1, __2, __3);
+    let __temp0 = __action669(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1347(__temp0, __4, __5, __6)
+    __action1347(
+        __temp0,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1614(
+fn __action1614<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(__0);
+    let __temp0 = __action408(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1348(__temp0, __1, __2)
+    __action1348(
+        __temp0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1615(
+fn __action1615<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(__0, __1, __2);
+    let __temp0 = __action668(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1348(__temp0, __3, __4)
+    __action1348(
+        __temp0,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1616(
+fn __action1616<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(__0, __1, __2, __3);
+    let __temp0 = __action669(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1348(__temp0, __4, __5)
+    __action1348(
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1617(
+fn __action1617<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Arg, TextSize),
     __4: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(__0);
+    let __temp0 = __action408(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1349(__temp0, __1, __2, __3, __4)
+    __action1349(
+        __temp0,
+        __1,
+        __2,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1618(
+fn __action1618<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -51197,16 +61982,28 @@ fn __action1618(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Arg, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(__0, __1, __2);
+    let __temp0 = __action668(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1349(__temp0, __3, __4, __5, __6)
+    __action1349(
+        __temp0,
+        __3,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1619(
+fn __action1619<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -51215,46 +62012,79 @@ fn __action1619(
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Arg, TextSize),
     __7: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(__0, __1, __2, __3);
+    let __temp0 = __action669(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1349(__temp0, __4, __5, __6, __7)
+    __action1349(
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1620(
+fn __action1620<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(__0);
+    let __temp0 = __action408(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1350(__temp0, __1, __2, __3)
+    __action1350(
+        __temp0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1621(
+fn __action1621<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(__0, __1, __2);
+    let __temp0 = __action668(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1350(__temp0, __3, __4, __5)
+    __action1350(
+        __temp0,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1622(
+fn __action1622<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -51262,84 +62092,139 @@ fn __action1622(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(__0, __1, __2, __3);
+    let __temp0 = __action669(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1350(__temp0, __4, __5, __6)
+    __action1350(
+        __temp0,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1623(
+fn __action1623<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(__0);
+    let __temp0 = __action408(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1351(__temp0)
+    __action1351(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1624(
+fn __action1624<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(__0, __1, __2);
+    let __temp0 = __action668(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1351(__temp0)
+    __action1351(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1625(
+fn __action1625<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(__0, __1, __2, __3);
+    let __temp0 = __action669(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1351(__temp0)
+    __action1351(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1626(
+fn __action1626<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __3: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(__0);
+    let __temp0 = __action408(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1352(__temp0, __1, __2, __3)
+    __action1352(
+        __temp0,
+        __1,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1627(
+fn __action1627<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __5: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(__0, __1, __2);
+    let __temp0 = __action668(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1352(__temp0, __3, __4, __5)
+    __action1352(
+        __temp0,
+        __3,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1628(
+fn __action1628<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -51347,292 +62232,501 @@ fn __action1628(
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
     __6: (TextSize, token::Tok, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(__0, __1, __2, __3);
+    let __temp0 = __action669(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1352(__temp0, __4, __5, __6)
+    __action1352(
+        __temp0,
+        __4,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1629(
+fn __action1629<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action408(__0);
+    let __temp0 = __action408(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1353(__temp0, __1, __2)
+    __action1353(
+        __temp0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1630(
+fn __action1630<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, token::Tok, TextSize),
     __4: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __2.2;
-    let __temp0 = __action668(__0, __1, __2);
+    let __temp0 = __action668(
+        __0,
+        __1,
+        __2,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1353(__temp0, __3, __4)
+    __action1353(
+        __temp0,
+        __3,
+        __4,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1631(
+fn __action1631<
+>(
     __0: (TextSize, Vec<ast::ArgWithDefault>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, alloc::vec::Vec<ast::ArgWithDefault>, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, Option<Box<ast::Arg>>, TextSize),
-) -> Result<ast::Arguments, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Arguments,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.0;
     let __end0 = __3.2;
-    let __temp0 = __action669(__0, __1, __2, __3);
+    let __temp0 = __action669(
+        __0,
+        __1,
+        __2,
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1353(__temp0, __4, __5)
+    __action1353(
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1632(
+fn __action1632<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Arguments, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action248(__1);
+    let __temp0 = __action248(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1269(__0, __temp0, __2, __3)
+    __action1269(
+        __0,
+        __temp0,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1633(
+fn __action1633<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> Result<ast::Expr, __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
+) -> Result<ast::Expr,__lalrpop_util::ParseError<TextSize,token::Tok,LexicalError>>
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action249(&__start0, &__end0);
+    let __temp0 = __action249(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1269(__0, __temp0, __1, __2)
+    __action1269(
+        __0,
+        __temp0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1634(
+fn __action1634<
+>(
     __0: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __3: (TextSize, Option<ast::Expr>, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action244(__3);
+    let __temp0 = __action244(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1397(__0, __1, __2, __temp0)
+    __action1397(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1635(
+fn __action1635<
+>(
     __0: (TextSize, core::option::Option<ast::Expr>, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, core::option::Option<ast::Expr>, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __2.2;
     let __end0 = __2.2;
-    let __temp0 = __action245(&__start0, &__end0);
+    let __temp0 = __action245(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1397(__0, __1, __2, __temp0)
+    __action1397(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1636(
+fn __action1636<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler {
+) -> ast::ExceptHandler
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action290(__1);
+    let __temp0 = __action290(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action763(__0, __temp0, __2, __3)
+    __action763(
+        __0,
+        __temp0,
+        __2,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1637(
+fn __action1637<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Suite, TextSize),
-) -> ast::ExceptHandler {
+) -> ast::ExceptHandler
+{
     let __start0 = __0.2;
     let __end0 = __1.0;
-    let __temp0 = __action291(&__start0, &__end0);
+    let __temp0 = __action291(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action763(__0, __temp0, __1, __2)
+    __action763(
+        __0,
+        __temp0,
+        __1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1638(
+fn __action1638<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> Option<ast::Expr> {
+) -> Option<ast::Expr>
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action290(__1);
+    let __temp0 = __action290(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action880(__0, __temp0)
+    __action880(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1639(__0: (TextSize, token::Tok, TextSize)) -> Option<ast::Expr> {
+fn __action1639<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> Option<ast::Expr>
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action291(&__start0, &__end0);
+    let __temp0 = __action291(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action880(__0, __temp0)
+    __action880(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1640(
+fn __action1640<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
     __3: (TextSize, Option<ast::Expr>, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
     let __start1 = __2.0;
     let __end1 = __2.2;
-    let __temp0 = __action290(__0);
+    let __temp0 = __action290(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    let __temp1 = __action290(__2);
+    let __temp1 = __action290(
+        __2,
+    );
     let __temp1 = (__start1, __temp1, __end1);
-    __action1634(__temp0, __1, __temp1, __3)
+    __action1634(
+        __temp0,
+        __1,
+        __temp1,
+        __3,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1641(
+fn __action1641<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, Option<ast::Expr>, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
     let __start1 = __1.2;
     let __end1 = __2.0;
-    let __temp0 = __action290(__0);
-    let __temp0 = (__start0, __temp0, __end0);
-    let __temp1 = __action291(&__start1, &__end1);
+    let __temp0 = __action290(
+        __0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    let __temp1 = __action291(
+        &__start1,
+        &__end1,
+    );
     let __temp1 = (__start1, __temp1, __end1);
-    __action1634(__temp0, __1, __temp1, __2)
+    __action1634(
+        __temp0,
+        __1,
+        __temp1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1642(
+fn __action1642<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, Option<ast::Expr>, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
     let __start1 = __1.0;
     let __end1 = __1.2;
-    let __temp0 = __action291(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    let __temp1 = __action290(__1);
+    let __temp0 = __action291(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    let __temp1 = __action290(
+        __1,
+    );
     let __temp1 = (__start1, __temp1, __end1);
-    __action1634(__temp0, __0, __temp1, __2)
+    __action1634(
+        __temp0,
+        __0,
+        __temp1,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1643(
+fn __action1643<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, Option<ast::Expr>, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
     let __start1 = __0.2;
     let __end1 = __1.0;
-    let __temp0 = __action291(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    let __temp1 = __action291(&__start1, &__end1);
+    let __temp0 = __action291(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    let __temp1 = __action291(
+        &__start1,
+        &__end1,
+    );
     let __temp1 = (__start1, __temp1, __end1);
-    __action1634(__temp0, __0, __temp1, __1)
+    __action1634(
+        __temp0,
+        __0,
+        __temp1,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1644(
+fn __action1644<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
     let __start1 = __2.0;
     let __end1 = __2.2;
-    let __temp0 = __action290(__0);
+    let __temp0 = __action290(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    let __temp1 = __action290(__2);
+    let __temp1 = __action290(
+        __2,
+    );
     let __temp1 = (__start1, __temp1, __end1);
-    __action1635(__temp0, __1, __temp1)
+    __action1635(
+        __temp0,
+        __1,
+        __temp1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1645(
+fn __action1645<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, token::Tok, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
     let __start1 = __1.2;
     let __end1 = __1.2;
-    let __temp0 = __action290(__0);
-    let __temp0 = (__start0, __temp0, __end0);
-    let __temp1 = __action291(&__start1, &__end1);
+    let __temp0 = __action290(
+        __0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    let __temp1 = __action291(
+        &__start1,
+        &__end1,
+    );
     let __temp1 = (__start1, __temp1, __end1);
-    __action1635(__temp0, __1, __temp1)
+    __action1635(
+        __temp0,
+        __1,
+        __temp1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1646(
+fn __action1646<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
     let __start1 = __1.0;
     let __end1 = __1.2;
-    let __temp0 = __action291(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    let __temp1 = __action290(__1);
+    let __temp0 = __action291(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    let __temp1 = __action290(
+        __1,
+    );
     let __temp1 = (__start1, __temp1, __end1);
-    __action1635(__temp0, __0, __temp1)
+    __action1635(
+        __temp0,
+        __0,
+        __temp1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1647(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
+fn __action1647<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.0;
     let __start1 = __0.2;
     let __end1 = __0.2;
-    let __temp0 = __action291(&__start0, &__end0);
-    let __temp0 = (__start0, __temp0, __end0);
-    let __temp1 = __action291(&__start1, &__end1);
+    let __temp0 = __action291(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    let __temp1 = __action291(
+        &__start1,
+        &__end1,
+    );
     let __temp1 = (__start1, __temp1, __end1);
-    __action1635(__temp0, __0, __temp1)
+    __action1635(
+        __temp0,
+        __0,
+        __temp1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1648(
+fn __action1648<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -51643,16 +62737,31 @@ fn __action1648(
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, token::Tok, TextSize),
     __9: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action210(__4);
+    let __temp0 = __action210(
+        __4,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1070(__0, __1, __2, __3, __temp0, __5, __6, __7, __8, __9)
+    __action1070(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __5,
+        __6,
+        __7,
+        __8,
+        __9,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1649(
+fn __action1649<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, token::Tok, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
@@ -51660,16 +62769,28 @@ fn __action1649(
     __4: (TextSize, ast::Expr, TextSize),
     __5: (TextSize, token::Tok, TextSize),
     __6: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __4.0;
     let __end0 = __4.2;
-    let __temp0 = __action210(__4);
+    let __temp0 = __action210(
+        __4,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1071(__0, __1, __2, __3, __temp0, __5, __6)
+    __action1071(
+        __0,
+        __1,
+        __2,
+        __3,
+        __temp0,
+        __5,
+        __6,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1650(
+fn __action1650<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
@@ -51679,185 +62800,293 @@ fn __action1650(
     __6: (TextSize, token::Tok, TextSize),
     __7: (TextSize, token::Tok, TextSize),
     __8: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action210(__3);
+    let __temp0 = __action210(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1072(__0, __1, __2, __temp0, __4, __5, __6, __7, __8)
+    __action1072(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __4,
+        __5,
+        __6,
+        __7,
+        __8,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1651(
+fn __action1651<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, token::Tok, TextSize),
     __3: (TextSize, ast::Expr, TextSize),
     __4: (TextSize, token::Tok, TextSize),
     __5: (TextSize, ast::Suite, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __3.0;
     let __end0 = __3.2;
-    let __temp0 = __action210(__3);
+    let __temp0 = __action210(
+        __3,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1073(__0, __1, __2, __temp0, __4, __5)
+    __action1073(
+        __0,
+        __1,
+        __2,
+        __temp0,
+        __4,
+        __5,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1652(__0: (TextSize, ast::Expr, TextSize)) -> core::option::Option<ast::Expr> {
+fn __action1652<
+>(
+    __0: (TextSize, ast::Expr, TextSize),
+) -> core::option::Option<ast::Expr>
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action210(__0);
+    let __temp0 = __action210(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action355(__temp0)
+    __action355(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1653(__0: (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action1653<
+>(
+    __0: (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action210(__0);
+    let __temp0 = __action210(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action28(__temp0)
+    __action28(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1654(__0: (TextSize, ast::Expr, TextSize)) -> ast::Expr {
+fn __action1654<
+>(
+    __0: (TextSize, ast::Expr, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action210(__0);
+    let __temp0 = __action210(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action30(__temp0)
+    __action30(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1655(
+fn __action1655<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Mod {
+) -> ast::Mod
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action210(__1);
+    let __temp0 = __action210(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1408(__0, __temp0)
+    __action1408(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1656(
+fn __action1656<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
     __2: (TextSize, alloc::vec::Vec<token::Tok>, TextSize),
-) -> ast::Mod {
+) -> ast::Mod
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action210(__1);
+    let __temp0 = __action210(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1409(__0, __temp0, __2)
+    __action1409(
+        __0,
+        __temp0,
+        __2,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1657(
+fn __action1657<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action1652(__1);
+    let __temp0 = __action1652(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1248(__0, __temp0)
+    __action1248(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1658(__0: (TextSize, token::Tok, TextSize)) -> ast::Stmt {
+fn __action1658<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> ast::Stmt
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action356(&__start0, &__end0);
+    let __temp0 = __action356(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1248(__0, __temp0)
+    __action1248(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1659(
+fn __action1659<
+>(
     __0: (TextSize, token::Tok, TextSize),
     __1: (TextSize, ast::Expr, TextSize),
-) -> ast::Expr {
+) -> ast::Expr
+{
     let __start0 = __1.0;
     let __end0 = __1.2;
-    let __temp0 = __action1652(__1);
+    let __temp0 = __action1652(
+        __1,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1430(__0, __temp0)
+    __action1430(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1660(__0: (TextSize, token::Tok, TextSize)) -> ast::Expr {
+fn __action1660<
+>(
+    __0: (TextSize, token::Tok, TextSize),
+) -> ast::Expr
+{
     let __start0 = __0.2;
     let __end0 = __0.2;
-    let __temp0 = __action356(&__start0, &__end0);
+    let __temp0 = __action356(
+        &__start0,
+        &__end0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1430(__0, __temp0)
+    __action1430(
+        __0,
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1661(__0: (TextSize, ast::Expr, TextSize)) -> ast::Stmt {
+fn __action1661<
+>(
+    __0: (TextSize, ast::Expr, TextSize),
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action1654(__0);
+    let __temp0 = __action1654(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1454(__temp0)
+    __action1454(
+        __temp0,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1662(
+fn __action1662<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, alloc::vec::Vec<ast::Expr>, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action1654(__0);
+    let __temp0 = __action1654(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1455(__temp0, __1)
+    __action1455(
+        __temp0,
+        __1,
+    )
 }
 
 #[allow(clippy::too_many_arguments)]
-fn __action1663(
+fn __action1663<
+>(
     __0: (TextSize, ast::Expr, TextSize),
     __1: (TextSize, ast::Operator, TextSize),
     __2: (TextSize, ast::Expr, TextSize),
-) -> ast::Stmt {
+) -> ast::Stmt
+{
     let __start0 = __0.0;
     let __end0 = __0.2;
-    let __temp0 = __action1654(__0);
+    let __temp0 = __action1654(
+        __0,
+    );
     let __temp0 = (__start0, __temp0, __end0);
-    __action1242(__temp0, __1, __2)
+    __action1242(
+        __temp0,
+        __1,
+        __2,
+    )
 }
 #[allow(clippy::type_complexity)]
 
-pub trait __ToTriple {
-    fn to_triple(
-        value: Self,
-    ) -> Result<
-        (TextSize, token::Tok, TextSize),
-        __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-    >;
-}
-
-impl __ToTriple for (TextSize, token::Tok, TextSize) {
-    fn to_triple(
-        value: Self,
-    ) -> Result<
-        (TextSize, token::Tok, TextSize),
-        __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-    > {
+pub trait __ToTriple<>
+{
+    fn to_triple(value: Self) -> Result<(TextSize,token::Tok,TextSize), __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>>;
+}
+
+impl<> __ToTriple<> for (TextSize, token::Tok, TextSize)
+{
+    fn to_triple(value: Self) -> Result<(TextSize,token::Tok,TextSize), __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
         Ok(value)
     }
 }
-impl __ToTriple for Result<(TextSize, token::Tok, TextSize), LexicalError> {
-    fn to_triple(
-        value: Self,
-    ) -> Result<
-        (TextSize, token::Tok, TextSize),
-        __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>,
-    > {
+impl<> __ToTriple<> for Result<(TextSize, token::Tok, TextSize), LexicalError>
+{
+    fn to_triple(value: Self) -> Result<(TextSize,token::Tok,TextSize), __lalrpop_util::ParseError<TextSize, token::Tok, LexicalError>> {
         match value {
             Ok(v) => Ok(v),
             Err(error) => Err(__lalrpop_util::ParseError::User { error }),

From 3617a6c52b9c9160a6c4244fa0eb34c66626e123 Mon Sep 17 00:00:00 2001
From: Zanie <contact@zanie.dev>
Date: Mon, 10 Jul 2023 16:48:05 -0500
Subject: [PATCH 5/6] Bump size assertion for `Stmt` from 136 to 160 bytes

---
 ast/src/impls.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ast/src/impls.rs b/ast/src/impls.rs
index 3c267e85..594fadb3 100644
--- a/ast/src/impls.rs
+++ b/ast/src/impls.rs
@@ -57,7 +57,7 @@ impl<R> Expr<R> {
 #[cfg(target_arch = "x86_64")]
 static_assertions::assert_eq_size!(crate::Expr, [u8; 72]);
 #[cfg(target_arch = "x86_64")]
-static_assertions::assert_eq_size!(crate::Stmt, [u8; 136]);
+static_assertions::assert_eq_size!(crate::Stmt, [u8; 160]);
 #[cfg(target_arch = "x86_64")]
 static_assertions::assert_eq_size!(crate::Pattern, [u8; 96]);
 #[cfg(target_arch = "x86_64")]

From 7516c4248c46c0bc4f25c575c3398cb2af6836b9 Mon Sep 17 00:00:00 2001
From: Zanie <contact@zanie.dev>
Date: Tue, 11 Jul 2023 09:42:45 -0500
Subject: [PATCH 6/6] Move `type_param` stubs into LALRPOP definition

---
 parser/src/python.lalrpop | 7 +++++--
 parser/src/python.rs      | 2 +-
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/parser/src/python.lalrpop b/parser/src/python.lalrpop
index 272cf97e..b6e823dc 100644
--- a/parser/src/python.lalrpop
+++ b/parser/src/python.lalrpop
@@ -970,10 +970,11 @@ FuncDef: ast::Stmt = {
         let returns = r.map(|x| Box::new(x));
         let end_location = body.last().unwrap().end();
         let type_comment = None;
+        let type_params = Vec::new();
         if is_async.is_some() {
-            ast::StmtAsyncFunctionDef { name, args, body, decorator_list, returns, type_comment, range: (location..end_location).into() }.into()
+            ast::StmtAsyncFunctionDef { name, args, body, decorator_list, returns, type_comment, type_params, range: (location..end_location).into() }.into()
         } else {
-            ast::StmtFunctionDef { name, args, body, decorator_list, returns, type_comment, range: (location..end_location).into() }.into()
+            ast::StmtFunctionDef { name, args, body, decorator_list, returns, type_comment, type_params, range: (location..end_location).into() }.into()
         }
     },
 };
@@ -1131,6 +1132,7 @@ ClassDef: ast::Stmt = {
             None => (vec![], vec![]),
         };
         let end_location = body.last().unwrap().end();
+        let type_params = Vec::new();
         ast::Stmt::ClassDef(
             ast::StmtClassDef {
                 name,
@@ -1138,6 +1140,7 @@ ClassDef: ast::Stmt = {
                 keywords,
                 body,
                 decorator_list,
+                type_params,
                 range: (location..end_location).into()
             },
         )
diff --git a/parser/src/python.rs b/parser/src/python.rs
index e2d1c9d0..f5f9f7be 100644
--- a/parser/src/python.rs
+++ b/parser/src/python.rs
@@ -1,5 +1,5 @@
 // auto-generated: "lalrpop 0.20.0"
-// sha3: c39f9711066c6f94aaf93d62d86b41efb4242ddcdcbe5b9d35e5a77a14ff22d6
+// sha3: 63c75be3af99ad823887ab5407feb1d091c0c150fc7ec64c257b95becfbbe6be
 use crate::{
     ast::{self as ast, Ranged, bigint::BigInt},
     lexer::{LexicalError, LexicalErrorType},