From 324f7915beed9c543de69bebdc5deaa86c060e5a Mon Sep 17 00:00:00 2001
From: Yehuda Katz <wycats@gmail.com>
Date: Wed, 5 Jun 2019 23:34:59 -0700
Subject: [PATCH] Span all the things

Also set up builder infra for more consistent AST creation.
---
 src/cli.rs                 |   70 +-
 src/commands/classified.rs |    1 +
 src/errors.rs              |    1 +
 src/evaluate/evaluator.rs  |   24 +-
 src/object/base.rs         |    9 +-
 src/parser.rs              |   73 +-
 src/parser/ast.rs          |  735 ++++--
 src/parser/lexer.rs        |   28 +-
 src/parser/parser.lalrpop  |   78 +-
 src/parser/parser.rs       | 4701 +++++++++++++++++++++++++-----------
 src/parser/registry.rs     |   46 +-
 11 files changed, 4006 insertions(+), 1760 deletions(-)

diff --git a/src/cli.rs b/src/cli.rs
index dbba22048..1d5c6ea7f 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -10,8 +10,8 @@ use crate::evaluate::Scope;
 crate use crate::format::{EntriesListView, GenericView};
 use crate::git::current_branch;
 use crate::object::Value;
-use crate::parser::ast::{Expression, Leaf};
-use crate::parser::{Args, ParsedCommand, Pipeline};
+use crate::parser::ast::{Expression, Leaf, RawExpression};
+use crate::parser::{Args, Pipeline};
 use crate::stream::empty_stream;
 
 use log::debug;
@@ -324,43 +324,51 @@ fn classify_command(
     // let command_name = &command.name[..];
     // let args = &command.args;
 
-    if let Expression::Call(call) = command {
+    if let Expression {
+        expr: RawExpression::Call(call),
+        ..
+    } = command
+    {
         match (&call.name, &call.args) {
-            (Expression::Leaf(Leaf::Bare(name)), args) => {
-                match context.has_command(&name.to_string()) {
-                    true => {
-                        let command = context.get_command(&name.to_string());
-                        let config = command.config();
-                        let scope = Scope::empty();
+            (
+                Expression {
+                    expr: RawExpression::Leaf(Leaf::Bare(name)),
+                    ..
+                },
+                args,
+            ) => match context.has_command(&name.to_string()) {
+                true => {
+                    let command = context.get_command(&name.to_string());
+                    let config = command.config();
+                    let scope = Scope::empty();
 
-                        let args = match args {
-                            Some(args) => config.evaluate_args(args.iter(), &scope)?,
-                            None => Args::default(),
-                        };
+                    let args = match args {
+                        Some(args) => config.evaluate_args(args.iter(), &scope)?,
+                        None => Args::default(),
+                    };
 
-                        Ok(ClassifiedCommand::Internal(InternalCommand {
-                            command,
-                            args,
-                        }))
-                    }
-                    false => {
-                        let arg_list_strings: Vec<String> = match args {
-                            Some(args) => args.iter().map(|i| i.as_external_arg()).collect(),
-                            None => vec![],
-                        };
-
-                        Ok(ClassifiedCommand::External(ExternalCommand {
-                            name: name.to_string(),
-                            args: arg_list_strings,
-                        }))
-                    }
+                    Ok(ClassifiedCommand::Internal(InternalCommand {
+                        command,
+                        args,
+                    }))
                 }
-            }
+                false => {
+                    let arg_list_strings: Vec<String> = match args {
+                        Some(args) => args.iter().map(|i| i.as_external_arg()).collect(),
+                        None => vec![],
+                    };
+
+                    Ok(ClassifiedCommand::External(ExternalCommand {
+                        name: name.to_string(),
+                        args: arg_list_strings,
+                    }))
+                }
+            },
 
             (_, None) => Err(ShellError::string(
                 "Unimplemented command that is just an expression (1)",
             )),
-            (_, Some(args)) => Err(ShellError::string("Unimplemented dynamic command")),
+            (_, Some(_)) => Err(ShellError::string("Unimplemented dynamic command")),
         }
     } else {
         Err(ShellError::string(&format!(
diff --git a/src/commands/classified.rs b/src/commands/classified.rs
index 102e17866..44452635b 100644
--- a/src/commands/classified.rs
+++ b/src/commands/classified.rs
@@ -76,6 +76,7 @@ crate struct ClassifiedPipeline {
 }
 
 crate enum ClassifiedCommand {
+    #[allow(unused)]
     Expr(Expression),
     Internal(InternalCommand),
     External(ExternalCommand),
diff --git a/src/errors.rs b/src/errors.rs
index 495a05032..89d403add 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -63,6 +63,7 @@ pub struct ShellDiagnostic {
 }
 
 impl ShellDiagnostic {
+    #[allow(unused)]
     crate fn simple_diagnostic(
         span: impl Into<Span>,
         source: impl Into<String>,
diff --git a/src/evaluate/evaluator.rs b/src/evaluate/evaluator.rs
index 4f8c6a1f0..3e0531afa 100644
--- a/src/evaluate/evaluator.rs
+++ b/src/evaluate/evaluator.rs
@@ -22,15 +22,15 @@ impl Scope {
 
 crate fn evaluate_expr(expr: &ast::Expression, scope: &Scope) -> Result<Value, ShellError> {
     use ast::*;
-    match expr {
-        Expression::Call(c) => Err(ShellError::unimplemented("Evaluating call expression")),
-        Expression::Leaf(l) => Ok(evaluate_leaf(l)),
-        Expression::Parenthesized(p) => evaluate_expr(&p.expr, scope),
-        Expression::Flag(f) => Ok(Value::Primitive(Primitive::String(f.print()))),
-        Expression::Block(b) => evaluate_block(&b, scope),
-        Expression::Path(p) => evaluate_path(&p, scope),
-        Expression::Binary(b) => evaluate_binary(b, scope),
-        Expression::VariableReference(r) => evaluate_reference(r, scope),
+    match &expr.expr {
+        RawExpression::Call(_) => Err(ShellError::unimplemented("Evaluating call expression")),
+        RawExpression::Leaf(l) => Ok(evaluate_leaf(l)),
+        RawExpression::Parenthesized(p) => evaluate_expr(&p.expr, scope),
+        RawExpression::Flag(f) => Ok(Value::Primitive(Primitive::String(f.print()))),
+        RawExpression::Block(b) => evaluate_block(&b, scope),
+        RawExpression::Path(p) => evaluate_path(&p, scope),
+        RawExpression::Binary(b) => evaluate_binary(b, scope),
+        RawExpression::VariableReference(r) => evaluate_reference(r, scope),
     }
 }
 
@@ -63,7 +63,7 @@ fn evaluate_binary(binary: &ast::Binary, scope: &Scope) -> Result<Value, ShellEr
     let left = evaluate_expr(&binary.left, scope)?;
     let right = evaluate_expr(&binary.right, scope)?;
 
-    match left.compare(binary.operator, &right) {
+    match left.compare(&binary.operator, &right) {
         Some(v) => Ok(Value::boolean(v)),
         None => Err(ShellError::TypeError(format!(
             "Can't compare {} and {}",
@@ -83,8 +83,8 @@ fn evaluate_path(path: &ast::Path, scope: &Scope) -> Result<Value, ShellError> {
     let mut seen = vec![];
 
     for name in path.tail() {
-        let next = value.get_data_by_key(&name);
-        seen.push(name);
+        let next = value.get_data_by_key(&name.item);
+        seen.push(name.item.clone());
 
         match next {
             None => {
diff --git a/src/object/base.rs b/src/object/base.rs
index 2251ac4f3..050916574 100644
--- a/src/object/base.rs
+++ b/src/object/base.rs
@@ -134,9 +134,10 @@ impl Deserialize<'de> for Block {
     where
         D: Deserializer<'de>,
     {
-        Ok(Block::new(ast::Expression::Leaf(ast::Leaf::String(
-            format!("Unserializable block"),
-        ))))
+        let mut builder = ast::ExpressionBuilder::new();
+        let expr: ast::Expression = builder.string("Unserializable block");
+
+        Ok(Block::new(expr))
     }
 }
 
@@ -219,7 +220,7 @@ impl Value {
         }
     }
 
-    crate fn compare(&self, operator: ast::Operator, other: &Value) -> Option<bool> {
+    crate fn compare(&self, operator: &ast::Operator, other: &Value) -> Option<bool> {
         match operator {
             _ => {
                 let coerced = coerce_compare(self, other)?;
diff --git a/src/parser.rs b/src/parser.rs
index 88768be58..c96f68138 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -5,7 +5,7 @@ crate mod parser;
 crate mod registry;
 crate mod span;
 
-crate use ast::{ParsedCommand, Pipeline};
+crate use ast::Pipeline;
 crate use registry::{Args, CommandConfig};
 
 use crate::errors::ShellError;
@@ -33,7 +33,7 @@ pub fn parse(input: &str) -> Result<Pipeline, ShellError> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::parser::ast::{bare, flag, short, unit, var, Expression, Operator, Pipeline};
+    use crate::parser::ast::Pipeline;
     use pretty_assertions::assert_eq;
 
     fn assert_parse(source: &str, expected: Pipeline) {
@@ -61,30 +61,44 @@ mod tests {
         let printed = parsed.print();
 
         assert_eq!(parsed, expected);
-        assert_eq!(source, printed);
+        assert_eq!(printed, source);
     }
 
     macro_rules! commands {
-        ( $( ( $name:tt $( $command:expr)* ) )|* ) => {
-            Pipeline::new(vec![
+        ( $( ( $name:tt $( $command:ident ( $arg:expr ) )* ) )|* ) => {{
+            use $crate::parser::ast::{Expression, ExpressionBuilder};
+            let mut builder = crate::parser::ast::ExpressionBuilder::new();
+
+            builder.pipeline(vec![
                 $(
-                    command!($name $($command)*)
+                    (command!($name $($command($arg))*) as (&dyn Fn(&mut ExpressionBuilder) -> Expression))
                 ),*
             ])
-        }
+        }}
     }
 
     macro_rules! command {
-        ($name:ident $( $command:expr )*) => {
-            Expression::call(Expression::bare(stringify!($name)), vec![ $($command.into()),* ])
+        ($name:ident) => {
+            &|b: &mut $crate::parser::ast::ExpressionBuilder| b.call((
+                &|b: &mut $crate::parser::ast::ExpressionBuilder| b.bare(stringify!($name)),
+                vec![]
+            ))
         };
 
-        ($name:ident $( $command:expr )*) => {
-            Expression::call(Expression::bare(stringify!($name)), vec![ $($command.into()),* ])
+        ($name:ident $( $command:ident ( $body:expr ) )*) => {{
+            use $crate::parser::ast::{Expression, ExpressionBuilder};
+            &|b: &mut ExpressionBuilder| b.call((
+                (&|b: &mut ExpressionBuilder| b.bare(stringify!($name))) as (&dyn Fn(&mut ExpressionBuilder) -> Expression),
+                vec![$( (&|b: &mut ExpressionBuilder| b.$command($body)) as &dyn Fn(&mut ExpressionBuilder) -> Expression ),* ]))
+
+        }};
+
+        ($name:ident $( $command:ident ( $body:expr ) )*) => {
+            &|b: &mut $crate::parser::ast::ExpressionBuilder| b.call(|b| b.bare(stringify!($name)), vec![ $( |b| b.$command($body) ),* ])
         };
 
-        ($name:tt $( $command:expr )*) => {
-            Expression::call(Expression::bare($name), vec![ $($command.into()),* ])
+        ($name:tt $( $command:ident ( $body:expr ) )*) => {
+            &|b: &mut $crate::parser::ast::ExpressionBuilder| b.call((&|b| b.bare($name), vec![ $( &|b| b.$command($body) ),* ]))
         };
     }
 
@@ -100,7 +114,7 @@ mod tests {
             commands![
                 (open bare("Cargo.toml"))
                     | (select bare("package.authors"))
-                    | ("split-row" " ")
+                    | ("split-row" string(" "))
             ],
         );
 
@@ -122,7 +136,7 @@ mod tests {
 
         assert_parse(
             "open Cargo.toml -r",
-            commands![(open bare("Cargo.toml") short("r"))],
+            commands![(open bare("Cargo.toml") shorthand("r"))],
         );
 
         assert_parse(
@@ -132,7 +146,7 @@ mod tests {
 
         assert_parse(
             r#"config --get "ignore dups" | format-list"#,
-            commands![(config flag("get") "ignore dups") | ("format-list")],
+            commands![(config flag("get") string("ignore dups")) | ("format-list")],
         );
 
         assert_parse(
@@ -147,16 +161,16 @@ mod tests {
 
         assert_parse(
             "config --set tabs 2",
-            commands![(config flag("set") bare("tabs") 2)],
+            commands![(config flag("set") bare("tabs") int(2))],
         );
 
         assert_parse(
             r#"ls | skip 1 | first 2 | select "file name" | rm $it"#,
             commands![
                 (ls)
-                    | (skip 1)
-                    | (first 2)
-                    | (select "file name")
+                    | (skip int(1))
+                    | (first int(2))
+                    | (select string("file name"))
                     | (rm var("it"))
             ],
         );
@@ -165,7 +179,7 @@ mod tests {
             r#"git branch --merged | split-row "`n" | where $it != "* master""#,
             commands![
                 // TODO: Handle escapes correctly. Should we do ` escape because of paths?
-                (git bare("branch") flag("merged")) | ("split-row" "`n") | (where binary(var("it"), "!=", "* master"))
+                (git bare("branch") flag("merged")) | ("split-row" string("`n")) | (where binary((&|b| b.var("it"), &|b| b.op("!="), &|b| b.string("* master"))))
             ],
         );
 
@@ -175,7 +189,7 @@ mod tests {
                 (open bare("input2.json"))
                     | ("from-json")
                     | (select bare("glossary.GlossDiv.GlossList.GlossEntry.GlossDef.GlossSeeAlso"))
-                    | (where binary(var("it"), ">", "GML"))
+                    | (where binary((&|b| b.var("it"), &|b| b.op(">"), &|b| b.string("GML"))))
             ]
         );
 
@@ -189,16 +203,15 @@ mod tests {
         assert_parse(
             "ls | where size < 1KB",
             commands![
-                (ls) | (where binary(bare("size"), "<", unit(1, "KB")))
+                (ls) | (where binary((&|b| b.bare("size"), &|b| b.op("<"), &|b| b.unit((1, "KB")))))
             ],
         );
-    }
 
-    fn binary(
-        left: impl Into<Expression>,
-        op: impl Into<Operator>,
-        right: impl Into<Expression>,
-    ) -> Expression {
-        Expression::binary(left, op, right)
+        assert_parse(
+            "ls | where { $it.size > 100 }",
+            commands![
+                (ls) | (where block(&|b| b.binary((&|b| b.path((&|b| b.var("it"), vec!["size"])), &|b| b.op(">"), &|b| b.int(100)))))
+            ],
+        )
     }
 }
diff --git a/src/parser/ast.rs b/src/parser/ast.rs
index 9a859d4c5..9360a8c5a 100644
--- a/src/parser/ast.rs
+++ b/src/parser/ast.rs
@@ -1,4 +1,4 @@
-use crate::parser::lexer::SpannedToken;
+use crate::parser::lexer::{Span, Spanned};
 use crate::prelude::*;
 use adhoc_derive::FromStr;
 use derive_new::new;
@@ -7,6 +7,381 @@ use serde_derive::{Deserialize, Serialize};
 use std::io::Write;
 use std::str::FromStr;
 
+#[derive(new)]
+pub struct ExpressionBuilder {
+    #[new(default)]
+    pos: usize,
+}
+
+#[allow(unused)]
+impl ExpressionBuilder {
+    pub fn op(&mut self, input: impl Into<Operator>) -> Spanned<Operator> {
+        let input = input.into();
+
+        let (start, end) = self.consume(input.as_str());
+
+        self.pos = end;
+
+        ExpressionBuilder::spanned_op(input, start, end)
+    }
+
+    pub fn spanned_op(input: impl Into<Operator>, start: usize, end: usize) -> Spanned<Operator> {
+        Spanned {
+            span: Span::from((start, end)),
+            item: input.into(),
+        }
+    }
+
+    pub fn string(&mut self, input: impl Into<String>) -> Expression {
+        let input = input.into();
+
+        let (start, _) = self.consume("\"");
+        self.consume(&input);
+        let (_, end) = self.consume("\"");
+        self.pos = end;
+
+        ExpressionBuilder::spanned_string(input, start, end)
+    }
+
+    pub fn spanned_string(input: impl Into<String>, start: usize, end: usize) -> Expression {
+        let input = input.into();
+
+        Expression {
+            span: Span::from((start, end)),
+            expr: RawExpression::Leaf(Leaf::String(input)),
+        }
+    }
+
+    pub fn bare(&mut self, input: impl Into<Bare>) -> Expression {
+        let input = input.into();
+
+        let (start, end) = self.consume(&input.body);
+        self.pos = end;
+
+        ExpressionBuilder::spanned_bare(input, start, end)
+    }
+
+    pub fn spanned_bare(input: impl Into<Bare>, start: usize, end: usize) -> Expression {
+        let input = input.into();
+
+        Expression {
+            span: Span::from((start, end)),
+            expr: RawExpression::Leaf(Leaf::Bare(input)),
+        }
+    }
+
+    pub fn boolean(&mut self, input: impl Into<bool>) -> Expression {
+        let boolean = input.into();
+
+        let (start, end) = match boolean {
+            true => self.consume("$yes"),
+            false => self.consume("$no"),
+        };
+
+        self.pos = end;
+
+        ExpressionBuilder::spanned_boolean(boolean, start, end)
+    }
+
+    pub fn spanned_boolean(input: impl Into<bool>, start: usize, end: usize) -> Expression {
+        let input = input.into();
+
+        Expression {
+            span: Span::from((start, end)),
+            expr: RawExpression::Leaf(Leaf::Boolean(input)),
+        }
+    }
+
+    pub fn int(&mut self, input: impl Into<i64>) -> Expression {
+        let int = input.into();
+
+        let (start, end) = self.consume(&int.to_string());
+        self.pos = end;
+
+        ExpressionBuilder::spanned_int(int, start, end)
+    }
+
+    pub fn spanned_int(input: impl Into<i64>, start: usize, end: usize) -> Expression {
+        let input = input.into();
+
+        Expression {
+            span: Span::from((start, end)),
+            expr: RawExpression::Leaf(Leaf::Int(input)),
+        }
+    }
+
+    pub fn unit(&mut self, input: (impl Into<i64>, impl Into<Unit>)) -> Expression {
+        let (int, unit) = (input.0.into(), input.1.into());
+
+        let (start, _) = self.consume(&int.to_string());
+        let (_, end) = self.consume(&unit.to_string());
+        self.pos = end;
+
+        ExpressionBuilder::spanned_unit((int, unit), start, end)
+    }
+
+    pub fn spanned_unit(
+        input: (impl Into<i64>, impl Into<Unit>),
+        start: usize,
+        end: usize,
+    ) -> Expression {
+        let (int, unit) = (input.0.into(), input.1.into());
+
+        Expression {
+            span: Span::from((start, end)),
+            expr: RawExpression::Leaf(Leaf::Unit(int, unit)),
+        }
+    }
+
+    pub fn flag(&mut self, input: impl Into<String>) -> Expression {
+        let input = input.into();
+
+        let (start, _) = self.consume("--");
+        let (_, end) = self.consume(&input);
+        self.pos = end;
+
+        ExpressionBuilder::spanned_flag(input, start, end)
+    }
+
+    pub fn spanned_flag(input: impl Into<String>, start: usize, end: usize) -> Expression {
+        let input = input.into();
+
+        Expression {
+            span: Span::from((start, end)),
+            expr: RawExpression::Flag(Flag::Longhand(input)),
+        }
+    }
+
+    pub fn shorthand(&mut self, input: impl Into<String>) -> Expression {
+        let int = input.into();
+
+        let size = int.to_string().len();
+
+        let start = self.pos;
+        let end = self.pos + size + 1;
+        self.pos = end;
+
+        ExpressionBuilder::spanned_shorthand(int, start, end)
+    }
+
+    pub fn spanned_shorthand(input: impl Into<String>, start: usize, end: usize) -> Expression {
+        let input = input.into();
+
+        Expression {
+            span: Span::from((start, end)),
+            expr: RawExpression::Flag(Flag::Shorthand(input)),
+        }
+    }
+
+    pub fn parens(
+        &mut self,
+        input: impl FnOnce(&mut ExpressionBuilder) -> Expression,
+    ) -> Expression {
+        let (start, _) = self.consume("(");
+        let input = input(self);
+        let (_, end) = self.consume(")");
+        self.pos = end;
+
+        ExpressionBuilder::spanned_parens(input, start, end)
+    }
+
+    pub fn spanned_parens(input: Expression, start: usize, end: usize) -> Expression {
+        Expression {
+            span: Span::from((start, end)),
+            expr: RawExpression::Parenthesized(Box::new(Parenthesized::new(input))),
+        }
+    }
+
+    pub fn block(&mut self, input: &dyn Fn(&mut ExpressionBuilder) -> Expression) -> Expression {
+        let (start, _) = self.consume("{ ");
+        let input = input(self);
+        let (_, end) = self.consume(" }");
+        self.pos = end;
+
+        ExpressionBuilder::spanned_block(input, start, end)
+    }
+
+    pub fn spanned_block(input: Expression, start: usize, end: usize) -> Expression {
+        Expression {
+            span: Span::from((start, end)),
+            expr: RawExpression::Block(Box::new(Block::new(input))),
+        }
+    }
+
+    pub fn binary(
+        &mut self,
+        input: (
+            &dyn Fn(&mut ExpressionBuilder) -> Expression,
+            &dyn Fn(&mut ExpressionBuilder) -> Spanned<Operator>,
+            &dyn Fn(&mut ExpressionBuilder) -> Expression,
+        ),
+    ) -> Expression {
+        let start = self.pos;
+
+        let left = (input.0)(self);
+        self.consume(" ");
+        let operator = (input.1)(self);
+        self.consume(" ");
+        let right = (input.2)(self);
+
+        let end = self.pos;
+
+        ExpressionBuilder::spanned_binary((left, operator, right), start, end)
+    }
+
+    pub fn spanned_binary(
+        input: (
+            impl Into<Expression>,
+            impl Into<Spanned<Operator>>,
+            impl Into<Expression>,
+        ),
+        start: usize,
+        end: usize,
+    ) -> Expression {
+        let binary = Binary::new(input.0, input.1.into(), input.2);
+
+        Expression {
+            span: Span::from((start, end)),
+            expr: RawExpression::Binary(Box::new(binary)),
+        }
+    }
+
+    pub fn path(
+        &mut self,
+        input: (
+            &dyn Fn(&mut ExpressionBuilder) -> Expression,
+            Vec<impl Into<String>>,
+        ),
+    ) -> Expression {
+        let start = self.pos;
+
+        let head = (input.0)(self);
+
+        let mut tail = vec![];
+
+        for item in input.1 {
+            self.consume(".");
+            let item = item.into();
+            let (start, end) = self.consume(&item);
+            tail.push(Spanned::new(Span::from((start, end)), item));
+        }
+
+        let end = self.pos;
+
+        ExpressionBuilder::spanned_path((head, tail), start, end)
+    }
+
+    pub fn spanned_path(
+        input: (impl Into<Expression>, Vec<Spanned<String>>),
+        start: usize,
+        end: usize,
+    ) -> Expression {
+        let path = Path::new(input.0.into(), input.1);
+
+        Expression {
+            span: Span::from((start, end)),
+            expr: RawExpression::Path(Box::new(path)),
+        }
+    }
+
+    pub fn call(
+        &mut self,
+        input: (
+            &(dyn Fn(&mut ExpressionBuilder) -> Expression),
+            Vec<&dyn Fn(&mut ExpressionBuilder) -> Expression>,
+        ),
+    ) -> Expression {
+        let start = self.pos;
+
+        let name = (&input.0)(self);
+
+        let mut args = vec![];
+
+        for item in input.1 {
+            self.consume(" ");
+            args.push(item(self));
+        }
+
+        let end = self.pos;
+
+        ExpressionBuilder::spanned_call((name, args), start, end)
+    }
+
+    pub fn spanned_call(input: impl Into<Call>, start: usize, end: usize) -> Expression {
+        let call = input.into();
+
+        Expression {
+            span: Span::from((start, end)),
+            expr: RawExpression::Call(Box::new(call)),
+        }
+    }
+
+    pub fn var(&mut self, input: impl Into<String>) -> Expression {
+        let input = input.into();
+        let (start, _) = self.consume("$");
+        let (_, end) = self.consume(&input);
+
+        ExpressionBuilder::spanned_var(input, start, end)
+    }
+
+    pub fn spanned_var(input: impl Into<String>, start: usize, end: usize) -> Expression {
+        let input = input.into();
+
+        let expr = match &input[..] {
+            "it" => RawExpression::VariableReference(Variable::It),
+            _ => RawExpression::VariableReference(Variable::Other(input)),
+        };
+
+        Expression {
+            span: Span::from((start, end)),
+            expr,
+        }
+    }
+
+    pub fn pipeline(
+        &mut self,
+        input: Vec<&dyn Fn(&mut ExpressionBuilder) -> Expression>,
+    ) -> Pipeline {
+        let start = self.pos;
+
+        let mut exprs = vec![];
+        let mut input = input.into_iter();
+
+        let next = input.next().unwrap();
+        exprs.push(next(self));
+
+        for item in input {
+            self.consume(" | ");
+            exprs.push(item(self));
+        }
+
+        let end = self.pos;
+
+        ExpressionBuilder::spanned_pipeline(exprs, start, end)
+    }
+
+    pub fn spanned_pipeline(input: Vec<Expression>, start: usize, end: usize) -> Pipeline {
+        Pipeline {
+            span: Span::from((start, end)),
+            commands: input,
+        }
+    }
+
+    pub fn sp(&mut self) {
+        self.consume(" ");
+    }
+
+    pub fn ws(&mut self, input: &str) {
+        self.consume(input);
+    }
+
+    fn consume(&mut self, input: &str) -> (usize, usize) {
+        let start = self.pos;
+        self.pos += input.len();
+        (start, self.pos)
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Deserialize, Serialize)]
 pub enum Operator {
     Equal,
@@ -19,13 +394,17 @@ pub enum Operator {
 
 impl Operator {
     pub fn print(&self) -> String {
+        self.as_str().to_string()
+    }
+
+    pub fn as_str(&self) -> &str {
         match *self {
-            Operator::Equal => "==".to_string(),
-            Operator::NotEqual => "!=".to_string(),
-            Operator::LessThan => "<".to_string(),
-            Operator::GreaterThan => ">".to_string(),
-            Operator::LessThanOrEqual => "<=".to_string(),
-            Operator::GreaterThanOrEqual => ">=".to_string(),
+            Operator::Equal => "==",
+            Operator::NotEqual => "!=",
+            Operator::LessThan => "<",
+            Operator::GreaterThan => ">",
+            Operator::LessThanOrEqual => "<=",
+            Operator::GreaterThanOrEqual => ">=",
         }
     }
 }
@@ -52,140 +431,127 @@ impl FromStr for Operator {
 }
 
 #[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq)]
-pub enum Expression {
+pub struct Expression {
+    crate expr: RawExpression,
+    crate span: Span,
+}
+
+impl std::ops::Deref for Expression {
+    type Target = RawExpression;
+
+    fn deref(&self) -> &RawExpression {
+        &self.expr
+    }
+}
+
+impl Expression {
+    crate fn print(&self) -> String {
+        self.expr.print()
+    }
+
+    crate fn as_external_arg(&self) -> String {
+        self.expr.as_external_arg()
+    }
+}
+
+#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq)]
+pub enum RawExpression {
     Leaf(Leaf),
     Flag(Flag),
     Parenthesized(Box<Parenthesized>),
     Block(Box<Block>),
     Binary(Box<Binary>),
     Path(Box<Path>),
-    Call(Box<ParsedCommand>),
+    Call(Box<Call>),
     VariableReference(Variable),
 }
 
-impl From<&str> for Expression {
-    fn from(input: &str) -> Expression {
-        Expression::Leaf(Leaf::String(input.into()))
-    }
-}
+impl RawExpression {
+    // crate fn leaf(leaf: impl Into<Leaf>) -> Expression {
+    //     Expression::Leaf(leaf.into())
+    // }
 
-impl From<String> for Expression {
-    fn from(input: String) -> Expression {
-        Expression::Leaf(Leaf::String(input.into()))
-    }
-}
+    // crate fn flag(flag: impl Into<Flag>) -> Expression {
+    //     Expression::Flag(flag.into())
+    // }
 
-impl From<i64> for Expression {
-    fn from(input: i64) -> Expression {
-        Expression::Leaf(Leaf::Int(input.into()))
-    }
-}
+    // crate fn call(head: Expression, tail: Vec<Expression>) -> Expression {
+    //     if tail.len() == 0 {
+    //         Expression::Call(Box::new(ParsedCommand::new(head.into(), None)))
+    //     } else {
+    //         Expression::Call(Box::new(ParsedCommand::new(head.into(), Some(tail))))
+    //     }
+    // }
 
-impl From<BarePath> for Expression {
-    fn from(input: BarePath) -> Expression {
-        Expression::Leaf(Leaf::Bare(input))
-    }
-}
+    // crate fn binary(
+    //     left: impl Into<Expression>,
+    //     operator: impl Into<Operator>,
+    //     right: impl Into<Expression>,
+    // ) -> Expression {
+    //     Expression::Binary(Box::new(Binary {
+    //         left: left.into(),
+    //         operator: operator.into(),
+    //         right: right.into(),
+    //     }))
+    // }
 
-impl From<Variable> for Expression {
-    fn from(input: Variable) -> Expression {
-        Expression::VariableReference(input)
-    }
-}
-
-impl From<Flag> for Expression {
-    fn from(input: Flag) -> Expression {
-        Expression::Flag(input)
-    }
-}
-
-impl From<Binary> for Expression {
-    fn from(input: Binary) -> Expression {
-        Expression::Binary(Box::new(input))
-    }
-}
-
-impl Expression {
-    crate fn leaf(leaf: impl Into<Leaf>) -> Expression {
-        Expression::Leaf(leaf.into())
-    }
-
-    crate fn flag(flag: impl Into<Flag>) -> Expression {
-        Expression::Flag(flag.into())
-    }
-
-    crate fn call(head: Expression, tail: Vec<Expression>) -> Expression {
-        if tail.len() == 0 {
-            Expression::Call(Box::new(ParsedCommand::new(head.into(), None)))
-        } else {
-            Expression::Call(Box::new(ParsedCommand::new(head.into(), Some(tail))))
-        }
-    }
-
-    crate fn binary(
-        left: impl Into<Expression>,
-        operator: impl Into<Operator>,
-        right: impl Into<Expression>,
-    ) -> Expression {
-        Expression::Binary(Box::new(Binary {
-            left: left.into(),
-            operator: operator.into(),
-            right: right.into(),
-        }))
-    }
-
-    crate fn block(expr: impl Into<Expression>) -> Expression {
-        Expression::Block(Box::new(Block::new(expr.into())))
-    }
+    // crate fn block(expr: impl Into<Expression>) -> Expression {
+    //     Expression::Block(Box::new(Block::new(expr.into())))
+    // }
 
     crate fn print(&self) -> String {
         match self {
-            Expression::Call(c) => c.print(),
-            Expression::Leaf(l) => l.print(),
-            Expression::Flag(f) => f.print(),
-            Expression::Parenthesized(p) => p.print(),
-            Expression::Block(b) => b.print(),
-            Expression::VariableReference(r) => r.print(),
-            Expression::Path(p) => p.print(),
-            Expression::Binary(b) => b.print(),
+            RawExpression::Call(c) => c.print(),
+            RawExpression::Leaf(l) => l.print(),
+            RawExpression::Flag(f) => f.print(),
+            RawExpression::Parenthesized(p) => p.print(),
+            RawExpression::Block(b) => b.print(),
+            RawExpression::VariableReference(r) => r.print(),
+            RawExpression::Path(p) => p.print(),
+            RawExpression::Binary(b) => b.print(),
         }
     }
 
     crate fn as_external_arg(&self) -> String {
         match self {
-            Expression::Call(c) => c.as_external_arg(),
-            Expression::Leaf(l) => l.as_external_arg(),
-            Expression::Flag(f) => f.as_external_arg(),
-            Expression::Parenthesized(p) => p.as_external_arg(),
-            Expression::Block(b) => b.as_external_arg(),
-            Expression::VariableReference(r) => r.as_external_arg(),
-            Expression::Path(p) => p.as_external_arg(),
-            Expression::Binary(b) => b.as_external_arg(),
+            RawExpression::Call(c) => c.as_external_arg(),
+            RawExpression::Leaf(l) => l.as_external_arg(),
+            RawExpression::Flag(f) => f.as_external_arg(),
+            RawExpression::Parenthesized(p) => p.as_external_arg(),
+            RawExpression::Block(b) => b.as_external_arg(),
+            RawExpression::VariableReference(r) => r.as_external_arg(),
+            RawExpression::Path(p) => p.as_external_arg(),
+            RawExpression::Binary(b) => b.as_external_arg(),
         }
     }
 
-    crate fn bare(path: impl Into<BarePath>) -> Expression {
-        Expression::Leaf(Leaf::Bare(path.into()))
-    }
-
     crate fn as_string(&self) -> Option<String> {
         match self {
-            Expression::Leaf(Leaf::String(s)) => Some(s.to_string()),
-            Expression::Leaf(Leaf::Bare(path)) => Some(path.to_string()),
+            RawExpression::Leaf(Leaf::String(s)) => Some(s.to_string()),
+            RawExpression::Leaf(Leaf::Bare(path)) => Some(path.to_string()),
             _ => None,
         }
     }
 
+    #[allow(unused)]
     crate fn as_bare(&self) -> Option<String> {
         match self {
-            Expression::Leaf(Leaf::Bare(p)) => Some(p.to_string()),
+            RawExpression::Leaf(Leaf::Bare(p)) => Some(p.to_string()),
+            _ => None,
+        }
+    }
+
+    #[allow(unused)]
+    crate fn as_block(&self) -> Option<Block> {
+        match self {
+            RawExpression::Block(block) => Some(*block.clone()),
             _ => None,
         }
     }
 
     crate fn is_flag(&self, value: &str) -> bool {
         match self {
-            Expression::Flag(Flag::Longhand(f)) if value == f => true,
+            RawExpression::Flag(Flag::Longhand(f)) if value == f => true,
             _ => false,
         }
     }
@@ -227,7 +593,7 @@ pub struct Path {
     head: Expression,
 
     #[get = "crate"]
-    tail: Vec<String>,
+    tail: Vec<Spanned<String>>,
 }
 
 impl Path {
@@ -235,7 +601,7 @@ impl Path {
         let mut out = self.head.print();
 
         for item in self.tail.iter() {
-            out.push_str(&format!(".{}", item));
+            out.push_str(&format!(".{}", item.item));
         }
 
         out
@@ -245,7 +611,7 @@ impl Path {
         let mut out = self.head.as_external_arg();
 
         for item in self.tail.iter() {
-            out.push_str(&format!(".{}", item));
+            out.push_str(&format!(".{}", item.item));
         }
 
         out
@@ -258,24 +624,7 @@ pub enum Variable {
     Other(String),
 }
 
-#[cfg(test)]
-crate fn var(name: &str) -> Expression {
-    match name {
-        "it" => Expression::VariableReference(Variable::It),
-        other => Expression::VariableReference(Variable::Other(other.to_string())),
-    }
-}
-
 impl Variable {
-    crate fn from_str(input: &str) -> Expression {
-        match input {
-            "it" => Expression::VariableReference(Variable::It),
-            "yes" => Expression::Leaf(Leaf::Boolean(true)),
-            "no" => Expression::Leaf(Leaf::Boolean(false)),
-            other => Expression::VariableReference(Variable::Other(other.to_string())),
-        }
-    }
-
     fn print(&self) -> String {
         match self {
             Variable::It => format!("$it"),
@@ -288,45 +637,34 @@ impl Variable {
     }
 }
 
-pub fn bare(s: impl Into<String>) -> BarePath {
-    BarePath {
-        head: s.into(),
-        tail: vec![],
+#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, new)]
+pub struct Bare {
+    body: String,
+}
+
+impl From<String> for Bare {
+    fn from(input: String) -> Bare {
+        Bare { body: input }
     }
 }
 
-#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq)]
-pub struct BarePath {
-    head: String,
-    tail: Vec<String>,
-}
-
-impl<T: Into<String>> From<T> for BarePath {
-    fn from(input: T) -> BarePath {
-        BarePath {
-            head: input.into(),
-            tail: vec![],
+impl From<&str> for Bare {
+    fn from(input: &str) -> Bare {
+        Bare {
+            body: input.to_string(),
         }
     }
 }
 
-impl BarePath {
-    crate fn from_token(head: SpannedToken) -> BarePath {
-        BarePath {
-            head: head.to_string(),
-            tail: vec![],
-        }
-    }
-
-    crate fn from_tokens(head: SpannedToken, tail: Vec<SpannedToken>) -> BarePath {
-        BarePath {
-            head: head.to_string(),
-            tail: tail.iter().map(|i| i.to_string()).collect(),
+impl Bare {
+    crate fn from_string(string: impl Into<String>) -> Bare {
+        Bare {
+            body: string.into(),
         }
     }
 
     crate fn to_string(&self) -> String {
-        bare_string(&self.head, &self.tail)
+        self.body.to_string()
     }
 }
 
@@ -363,30 +701,28 @@ impl Unit {
             Unit::PB => size * 1024 * 1024 * 1024 * 1024 * 1024,
         })
     }
-}
 
-#[cfg(test)]
-pub fn unit(num: i64, unit: impl Into<Unit>) -> Expression {
-    Expression::Leaf(Leaf::Unit(num, unit.into()))
+    crate fn to_string(&self) -> &str {
+        match self {
+            Unit::B => "B",
+            Unit::KB => "KB",
+            Unit::MB => "MB",
+            Unit::GB => "GB",
+            Unit::TB => "TB",
+            Unit::PB => "PB",
+        }
+    }
 }
 
 #[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq)]
 pub enum Leaf {
     String(String),
-    Bare(BarePath),
-
-    #[allow(unused)]
+    Bare(Bare),
     Boolean(bool),
     Int(i64),
     Unit(i64, Unit),
 }
 
-crate fn bare_string(head: &String, tail: &Vec<String>) -> String {
-    let mut out = vec![head.clone()];
-    out.extend(tail.clone());
-    itertools::join(out, ".")
-}
-
 impl Leaf {
     fn print(&self) -> String {
         match self {
@@ -412,14 +748,14 @@ impl Leaf {
 #[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq)]
 pub struct Binary {
     crate left: Expression,
-    crate operator: Operator,
+    crate operator: Spanned<Operator>,
     crate right: Expression,
 }
 
 impl Binary {
     crate fn new(
         left: impl Into<Expression>,
-        operator: Operator,
+        operator: Spanned<Operator>,
         right: impl Into<Expression>,
     ) -> Binary {
         Binary {
@@ -456,16 +792,6 @@ pub enum Flag {
     Longhand(String),
 }
 
-#[cfg(test)]
-crate fn flag(s: &str) -> Flag {
-    Flag::Longhand(s.into())
-}
-
-#[cfg(test)]
-crate fn short(s: &str) -> Flag {
-    Flag::Shorthand(s.into())
-}
-
 impl Flag {
     #[allow(unused)]
     crate fn print(&self) -> String {
@@ -482,12 +808,34 @@ impl Flag {
 }
 
 #[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, new)]
-pub struct ParsedCommand {
+pub struct Call {
     crate name: Expression,
     crate args: Option<Vec<Expression>>,
 }
 
-impl ParsedCommand {
+impl From<(Expression, Vec<Expression>)> for Call {
+    fn from(input: (Expression, Vec<Expression>)) -> Call {
+        Call {
+            name: input.0,
+            args: if input.1.len() == 0 {
+                None
+            } else {
+                Some(input.1)
+            },
+        }
+    }
+}
+
+impl From<Expression> for Call {
+    fn from(input: Expression) -> Call {
+        Call {
+            name: input,
+            args: None,
+        }
+    }
+}
+
+impl Call {
     fn as_external_arg(&self) -> String {
         let mut out = vec![];
 
@@ -517,35 +865,26 @@ impl ParsedCommand {
     }
 }
 
-impl From<&str> for ParsedCommand {
-    fn from(input: &str) -> ParsedCommand {
-        ParsedCommand {
-            name: Expression::Leaf(Leaf::Bare(bare(input))),
-            args: None,
-        }
-    }
-}
-
-impl From<(&str, Vec<Expression>)> for ParsedCommand {
-    fn from(input: (&str, Vec<Expression>)) -> ParsedCommand {
-        ParsedCommand {
-            name: Expression::bare(input.0),
-            args: Some(input.1),
-        }
-    }
-}
-
 #[derive(new, Debug, Eq, PartialEq)]
 pub struct Pipeline {
     crate commands: Vec<Expression>,
+    crate span: Span,
 }
 
 impl Pipeline {
-    crate fn from_parts(command: Expression, rest: Vec<Expression>) -> Pipeline {
+    crate fn from_parts(
+        command: Expression,
+        rest: Vec<Expression>,
+        start: usize,
+        end: usize,
+    ) -> Pipeline {
         let mut commands = vec![command];
         commands.extend(rest);
 
-        Pipeline { commands }
+        Pipeline {
+            commands,
+            span: Span::from((start, end)),
+        }
     }
 
     #[allow(unused)]
diff --git a/src/parser/lexer.rs b/src/parser/lexer.rs
index 047c3130e..53dce2c1b 100644
--- a/src/parser/lexer.rs
+++ b/src/parser/lexer.rs
@@ -317,8 +317,8 @@ impl logos::Extras for LexerState {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd)]
 pub struct Span {
-    start: usize,
-    end: usize,
+    crate start: usize,
+    crate end: usize,
     // source: &'source str,
 }
 
@@ -374,6 +374,26 @@ impl language_reporting::ReportingSpan for Span {
     }
 }
 
+#[derive(new, Debug, Clone, Eq, PartialEq, Ord, PartialOrd)]
+pub struct Spanned<T> {
+    crate span: Span,
+    crate item: T,
+}
+
+impl<T> std::ops::Deref for Spanned<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        &self.item
+    }
+}
+
+impl<T> Spanned<T> {
+    crate fn from_item(item: T, span: Span) -> Spanned<T> {
+        Spanned { span, item }
+    }
+}
+
 #[derive(new, Debug, Clone, Eq, PartialEq)]
 pub struct SpannedToken<'source> {
     crate span: Span,
@@ -382,6 +402,10 @@ pub struct SpannedToken<'source> {
 }
 
 impl SpannedToken<'source> {
+    crate fn to_spanned_string(&self) -> Spanned<String> {
+        Spanned::from_item(self.slice.to_string(), self.span)
+    }
+
     crate fn to_string(&self) -> String {
         self.slice.to_string()
     }
diff --git a/src/parser/parser.lalrpop b/src/parser/parser.lalrpop
index 61973f5cf..b2a6ff452 100644
--- a/src/parser/parser.lalrpop
+++ b/src/parser/parser.lalrpop
@@ -3,7 +3,7 @@
 use std::str::FromStr;
 use crate::parser::ast::*;
 use crate::prelude::*;
-use crate::parser::lexer::{SpannedToken, Token};
+use crate::parser::lexer::{SpannedToken, Spanned, Span, Token};
 use byte_unit::Byte;
 
 // nu's grammar is a little bit different from a lot of other languages, to better match
@@ -27,61 +27,69 @@ use byte_unit::Byte;
 grammar<'input>;
 
 pub Pipeline: Pipeline = {
-  <first:PipelineElement> <rest: ( "|" <PipelineElement> )*> => Pipeline::from_parts(first, rest),
+  <l: @L> <first:PipelineElement> <rest: ( "|" <PipelineElement> )*> <r: @R> => Pipeline::from_parts(first, rest, l, r),
 }
 
 PipelineElement: Expression = {
-    <Bare> => Expression::call(Expression::bare(<>), vec![]),
+    <l: @L> <bare: BareExpression> <r: @R> => ExpressionBuilder::spanned_call((bare, vec![]), l, r),
     <SingleExpression> => <>,
 }
 
 // A leaf expression is a single logical token that directly represents an expression
 LeafExpression: Expression = {
-    <String> => <>,
-    <Int> => Expression::leaf(Leaf::Int(<>)),
-    <UnitsNum> => <>,
-    <Var> => <>,
+    <String>,
+    <l: @L> <int: Int> <r: @R> => ExpressionBuilder::spanned_int(int, l, r),
+    <UnitsNum>,
+    <Var>,
 }
 
 pub Call: Expression = {
-    <expr:Expression> <rest:SingleCallArgument> => Expression::call(expr, vec![rest]),
-    <expr:Expression> <first:CallArgument> <rest:( <CallArgument> )+> => Expression::call(expr, { let mut rest = rest; let mut v = vec![first]; v.append(&mut rest); v }),
-    <expr:Bare> <rest:SingleCallArgument> => Expression::call(Expression::bare(expr), vec![rest]),
-    <expr:Bare> <first:CallArgument> <rest:( <CallArgument> )+> => Expression::call(Expression::bare(expr), { let mut v = vec![first]; let mut rest = rest; v.append(&mut rest); v }),
+    <l: @L> <expr:Expression> <rest:SingleCallArgument> <r: @R> => ExpressionBuilder::spanned_call((expr, vec![rest]), l, r),
+    <l: @L> <expr:Expression> <first:CallArgument> <rest:( <CallArgument> )+> <r: @R> => ExpressionBuilder::spanned_call((expr, { let mut rest = rest; let mut v = vec![first]; v.append(&mut rest); v }), l, r),
+    <l: @L> <expr:BareExpression> <rest:SingleCallArgument> <r: @R> => ExpressionBuilder::spanned_call((expr, vec![rest]), l, r),
+    <l: @L> <expr:BareExpression> <first:CallArgument> <rest:( <CallArgument> )+> <r: @R> => ExpressionBuilder::spanned_call((expr, { let mut v = vec![first]; let mut rest = rest; v.append(&mut rest); v }), l, r),
 }
 
 Binary: Expression = {
-    <left:ArgumentExpression> <op:Operator> <right:ArgumentExpression> => Expression::binary(left, op, right),
+    <l: @L> <left:ArgumentExpression> <op:SpannedOperator> <right:ArgumentExpression> <r: @R> => ExpressionBuilder::spanned_binary((left, op, right), l, r)
 }
 
 // In a block, a single bare word is interpreted as a call:
 //
 // foreach { ls }
 Block: Expression = {
-    "{" <SingleExpression> "}" => Expression::block(<>),
-    "{" <Bare> "}" => Expression::block(Expression::call(Expression::bare(<>), vec![])),
+    <l: @L> "{" <expr: SingleExpression> "}" <r: @R> => ExpressionBuilder::spanned_block(expr, l, r),
+    <l: @L> "{" <bare: BareExpression> "}" <r: @R> => {
+        let call = ExpressionBuilder::spanned_call(bare.clone(), bare.span.start, bare.span.end);
+        ExpressionBuilder::spanned_block(call, l, r)
+    }
 }
 
 // An `Expression` is the most general kind of expression. It can go anywhere, even right next to another expression, and
 // even as the first part of a call.
-Expression: Expression = {
+MemberHeadExpression: Expression = {
     <LeafExpression> => <>,
     <Block> => <>,
-    "(" <Call> ")" => <>,
-    "(" <Bare> ")" => Expression::call(Expression::bare(<>), vec![]),
-    "(" <Binary> ")" => <>,
+    <l: @L> "(" <expr: Call> ")" <r: @R> => ExpressionBuilder::spanned_call(expr, l, r),
+    <l: @L> "(" <expr: BareExpression> ")" <r: @R> => ExpressionBuilder::spanned_call((expr, vec![]), l, r),
+    <l: @L> "(" <expr:Binary> ")" <r: @R> => ExpressionBuilder::spanned_parens(expr, l, r),
+}
+
+Expression: Expression = {
+    <MemberHeadExpression> => <>,
+    <l: @L> <expr:MemberHeadExpression> <rest: ( "???." <"member"> )+> <r: @R> => ExpressionBuilder::spanned_path((expr, rest.iter().map(|i| i.to_spanned_string()).collect()), l, r),
 }
 
 // An `ArgumentExpression` is an expression that appears in an argument list. It includes all of `Expression`, and
 // bare words are interpreted as strings.
 ArgumentExpression: Expression = {
     <Expression>,
-    <Bare> => Expression::bare(<>),
+    <BareExpression>,
 }
 
 CallArgument: Expression = {
-    <ArgumentExpression> => <>,
-    <Flag> => Expression::flag(<>),
+    <ArgumentExpression>,
+    <Flag>,
 }
 
 SingleCallArgument: Expression = {
@@ -101,14 +109,22 @@ SingleExpression: Expression = {
     <Binary>,
 }
 
+BareExpression: Expression = {
+    <l: @L> <bare: Bare> <r: @R> => ExpressionBuilder::spanned_bare(bare, l, r)
+}
+
+SpannedOperator: Spanned<Operator> = {
+    <l: @L> <op: Operator> <r: @R> => Spanned::from_item(op, Span::from((l, r)))
+}
+
 // === LOGICAL TOKENS === //
 
 // A logical token may be composed of more than one raw token, but the tokens must be emitted
 // from the stream in exactly one sequence. This allows us to use parser infrastructure to
 // compose tokens without the risk that these logical tokens will introduce ambiguities.
 
-Bare: BarePath = {
-    <head: "bare"> => BarePath::from_token(head)
+Bare: Bare = {
+    <head: "bare"> => Bare::from_string(head.as_slice())
 }
 
 // A member is a special token that represents bare words or string literals immediate
@@ -129,25 +145,25 @@ Operator: Operator = {
 }
 
 Int: i64 = {
-    <"num"> => i64::from_str(<>.as_slice()).unwrap()
+    <n: "num"> => i64::from_str(<>.as_slice()).unwrap(),
 }
 
 UnitsNum: Expression = {
-    <num: Int> <unit: "unit"> => Expression::leaf(Leaf::Unit(num, Unit::from_str(unit.as_slice()).unwrap()))
+    <l: @L> <num: Int> <unit: "unit"> <r: @R> => ExpressionBuilder::spanned_unit((num, Unit::from_str(unit.as_slice()).unwrap()), l, r),
 }
 
 String: Expression = {
-    <"sqstring"> => <>.as_slice()[1..(<>.as_slice().len() - 1)].to_string().into(),
-    <"dqstring"> => <>.as_slice()[1..(<>.as_slice().len() - 1)].to_string().into()
+    <l: @L> <s: "sqstring"> <r: @R> => ExpressionBuilder::spanned_string(&s.as_slice()[1..(s.as_slice().len() - 1)], l, r),
+    <l: @L> <s: "dqstring"> <r: @R> => ExpressionBuilder::spanned_string(&s.as_slice()[1..(s.as_slice().len() - 1)], l, r),
 }
 
-Flag: Flag = {
-    "-" <Bare> => Flag::Shorthand(<>.to_string()),
-    "--" <Bare> => Flag::Longhand(<>.to_string()),
+Flag: Expression = {
+    <l: @L> "-" <b: Bare> <r: @R> => ExpressionBuilder::spanned_shorthand(b.to_string(), l, r),
+    <l: @L> "--" <b: Bare> <r: @R> => ExpressionBuilder::spanned_flag(b.to_string(), l, r),
 }
 
 Var: Expression = {
-    "$" <"variable"> => Variable::from_str(<>.as_slice()).into(),
+    <l: @L> "$" <v: "variable"> <r: @R> => ExpressionBuilder::spanned_var(v.as_slice(), l, r),
 }
 
 extern {
diff --git a/src/parser/parser.rs b/src/parser/parser.rs
index cb40b4f0b..e6f1208a0 100644
--- a/src/parser/parser.rs
+++ b/src/parser/parser.rs
@@ -1,10 +1,10 @@
 // auto-generated: "lalrpop 0.17.0"
-// sha256: ebcd72b764daf3e88a462534cd5f3f51fb424dd095904c6b2cde9368af95387
+// sha256: fcc54cbfc288e82dcd759b41803d54d69337bfffac5c19d297a91f1f97db993
 #![allow(unused)]
 use std::str::FromStr;
 use crate::parser::ast::*;
 use crate::prelude::*;
-use crate::parser::lexer::{SpannedToken, Token};
+use crate::parser::lexer::{SpannedToken, Spanned, Span, Token};
 use byte_unit::Byte;
 #[allow(unused_extern_crates)]
 extern crate lalrpop_util as __lalrpop_util;
@@ -18,7 +18,7 @@ mod __parse__Call {
     use std::str::FromStr;
     use crate::parser::ast::*;
     use crate::prelude::*;
-    use crate::parser::lexer::{SpannedToken, Token};
+    use crate::parser::lexer::{SpannedToken, Spanned, Span, Token};
     use byte_unit::Byte;
     #[allow(unused_extern_crates)]
     extern crate lalrpop_util as __lalrpop_util;
@@ -29,206 +29,224 @@ mod __parse__Call {
     pub enum __Symbol<'input>
      {
         Variant0(SpannedToken<'input>),
-        Variant1(Expression),
-        Variant2(::std::vec::Vec<Expression>),
-        Variant3(BarePath),
-        Variant4(Flag),
-        Variant5(i64),
-        Variant6(String),
-        Variant7(Operator),
-        Variant8(Pipeline),
+        Variant1(::std::vec::Vec<SpannedToken<'input>>),
+        Variant2(Expression),
+        Variant3(::std::vec::Vec<Expression>),
+        Variant4(usize),
+        Variant5(Bare),
+        Variant6(i64),
+        Variant7(String),
+        Variant8(Operator),
+        Variant9(Pipeline),
+        Variant10(Spanned<Operator>),
     }
     const __ACTION: &'static [i8] = &[
         // State 0
-        0, 11, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 14, 0, 15, 0, 16, 0, 0, 17, 0, 0,
+        0, 13, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 16, 0, 17, 0, 18, 0, 0, 19, 0, 0,
         // State 1
-        0, 11, 12, 0, 25, 26, 0, 0, 0, 0, 0, 0, 13, 0, 14, 0, 15, 0, 16, 0, 0, 17, 0, 0,
+        -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, 0, -17, 0, -17, 0, -17, 0, -17, 0, 0, -17, 0, -17,
         // State 2
-        -22, -22, -22, -22, -22, -22, -22, -22, -22, -22, -22, 0, -22, 0, -22, 0, -22, 0, -22, 0, 0, -22, 0, -22,
+        0, 13, 14, 0, 27, 28, 0, 0, 0, 0, 0, 0, 15, 0, 16, 0, 17, 0, 18, 0, 0, 19, 0, 0,
         // State 3
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, 0, -40, 0, -40, 0, -40, 0, 0, -40, 0, -40,
         // State 4
-        0, 11, 12, 0, 25, 26, 0, 0, 0, 0, 0, 0, 13, 0, 14, 0, 15, 0, 16, 0, 0, 17, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 5
-        -30, -30, -30, -30, -30, -30, -30, -30, -30, -30, -30, 0, -30, 0, -30, 0, -30, 0, -30, 29, 0, -30, 0, -30,
+        0, 13, 14, 0, 27, 28, 0, 0, 0, 0, 0, 0, 15, 0, 16, 0, 17, 0, 18, 0, 0, 19, 0, 0,
         // State 6
-        -21, -21, -21, -21, -21, -21, -21, -21, -21, -21, -21, 0, -21, 0, -21, 0, -21, 0, -21, 0, 0, -21, 0, -21,
+        -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, 0, -33, 0, -33, 0, -33, 31, 0, -33, 0, -33,
         // State 7
-        -29, -29, -29, -29, -29, -29, -29, -29, -29, -29, -29, 0, -29, 0, -29, 0, -29, 0, -29, 0, 0, -29, 0, -29,
+        -39, -39, -39, -39, -39, -39, -39, -39, -39, -39, -39, -39, -39, 0, -39, 0, -39, 0, -39, 0, 0, -39, 0, -39,
         // State 8
-        -31, -31, -31, -31, -31, -31, -31, -31, -31, -31, -31, 0, -31, 0, -31, 0, -31, 0, -31, 0, 0, -31, 0, -31,
+        -27, -27, -27, -27, -27, -27, -27, -27, -27, -27, -27, 33, -27, 0, -27, 0, -27, 0, -27, 0, 0, -27, 0, -27,
         // State 9
-        -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, 0, -32, 0, -32, 0, -32, 0, -32, 0, 0, -32, 0, -32,
+        -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, 0, -32, 0, -32, 0, -32, 0, 0, -32, 0, -32,
         // State 10
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 30, 0, 0, 0,
+        -34, -34, -34, -34, -34, -34, -34, -34, -34, -34, -34, -34, -34, 0, -34, 0, -34, 0, -34, 0, 0, -34, 0, -34,
         // State 11
-        0, 11, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 14, 0, 15, 0, 16, 0, 0, 17, 0, 0,
+        -35, -35, -35, -35, -35, -35, -35, -35, -35, -35, -35, -35, -35, 0, -35, 0, -35, 0, -35, 0, 0, -35, 0, -35,
         // State 12
-        -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, 0, -11, 0, -11, 0, -11, 0, -11, 0, 0, -11, 0, -11,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, 0, 0, 0,
         // State 13
-        -52, -52, -52, -52, -52, -52, -52, -52, -52, -52, -52, 0, -52, 0, -52, 0, -52, 0, -52, 0, 0, -52, 0, -52,
+        0, 13, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 16, 0, 17, 0, 18, 0, 0, 19, 0, 0,
         // State 14
-        -28, -28, -28, -28, -28, -28, -28, -28, -28, -28, -28, 0, -28, 0, -28, 0, -28, 0, -28, -28, 0, -28, 0, -28,
+        -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, 0, -16, 0, -16, 0, -16, 0, -16, 0, 0, -16, 0, -16,
         // State 15
-        -51, -51, -51, -51, -51, -51, -51, -51, -51, -51, -51, 0, -51, 0, -51, 0, -51, 0, -51, 0, 0, -51, 0, -51,
+        -61, -61, -61, -61, -61, -61, -61, -61, -61, -61, -61, -61, -61, 0, -61, 0, -61, 0, -61, 0, 0, -61, 0, -61,
         // State 16
-        0, 11, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 14, 0, 15, 0, 16, 0, 0, 17, 0, 0,
+        -31, -31, -31, -31, -31, -31, -31, -31, -31, -31, -31, -31, -31, 0, -31, 0, -31, 0, -31, -31, 0, -31, 0, -31,
         // State 17
-        42, -19, -19, -19, -19, -19, 43, 44, 45, 46, 47, 0, -19, 0, -19, 0, -19, 0, -19, 0, 0, -19, 0, -19,
+        -60, -60, -60, -60, -60, -60, -60, -60, -60, -60, -60, -60, -60, 0, -60, 0, -60, 0, -60, 0, 0, -60, 0, -60,
         // State 18
-        -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, 0, -10, 0, -10, 0, -10, 0, -10, 0, 0, -10, 0, -10,
+        0, 13, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 16, 0, 17, 0, 18, 0, 0, 19, 0, 0,
         // State 19
-        0, 0, 0, -47, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -47,
+        47, -25, -25, -25, -25, -25, 48, 49, 50, 51, 52, 0, -25, 0, -25, 0, -25, 0, -25, 0, 0, -25, 0, -25,
         // State 20
-        0, 11, 12, -46, 25, 26, 0, 0, 0, 0, 0, 0, 13, 0, 14, 0, 15, 0, 16, 0, 0, 17, 0, -46,
+        -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, 0, -15, 0, -15, 0, -15, 0, -15, 0, 0, -15, 0, -15,
         // State 21
-        -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, 0, -9, 0, -9, 0, -9, 0, -9, 0, 0, -9, 0, -9,
+        0, 0, 0, -55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -55,
         // State 22
-        0, -20, -20, -20, -20, -20, 0, 0, 0, 0, 0, 0, -20, 0, -20, 0, -20, 0, -20, 0, 0, -20, 0, -20,
+        0, 13, 14, -54, 27, 28, 0, 0, 0, 0, 0, 0, 15, 0, 16, 0, 17, 0, 18, 0, 0, 19, 0, -54,
         // State 23
-        0, 0, 0, -17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -17,
-        // State 24
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        // State 25
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        // State 26
-        0, 11, 12, -46, 25, 26, 0, 0, 0, 0, 0, 0, 13, 0, 14, 0, 15, 0, 16, 0, 0, 17, 0, -46,
-        // State 27
-        0, 0, 0, -15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -15,
-        // State 28
-        -53, -53, -53, -53, -53, -53, -53, -53, -53, -53, -53, 0, -53, 0, -53, 0, -53, 0, -53, 0, 0, -53, 0, -53,
-        // State 29
-        -54, -54, -54, -54, -54, -54, -54, -54, -54, -54, -54, 0, -54, 0, -54, 0, -54, 0, -54, 0, 0, -54, 0, -54,
-        // State 30
-        42, 0, 0, 0, 0, 0, 43, 44, 45, 46, 47, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        // State 31
-        -10, 11, 12, 54, 25, 26, -10, -10, -10, -10, -10, 0, 13, 0, 14, 0, 15, 0, 16, 0, 0, 17, 0, 0,
-        // State 32
-        0, 0, 0, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        // State 33
-        0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        // State 34
-        -9, 11, 12, 0, 25, 26, -9, -9, -9, -9, -9, 0, 13, 0, 14, 0, 15, 0, 16, 0, 0, 17, 0, 0,
-        // State 35
-        -10, 11, 12, 0, 25, 26, -10, -10, -10, -10, -10, 0, 13, 0, 14, 0, 15, 0, 16, 0, 0, 17, 0, 57,
-        // State 36
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -50,
-        // State 37
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -49,
-        // State 38
-        -9, 11, 12, 0, 25, 26, -9, -9, -9, -9, -9, 0, 13, 0, 14, 0, 15, 0, 16, 0, 0, 17, 0, -48,
-        // State 39
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 58,
-        // State 40
-        0, 11, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 14, 0, 15, 0, 16, 0, 0, 17, 0, 0,
-        // State 41
-        0, -37, -37, 0, 0, 0, 0, 0, 0, 0, 0, 0, -37, 0, -37, 0, -37, 0, -37, 0, 0, -37, 0, 0,
-        // State 42
-        0, -38, -38, 0, 0, 0, 0, 0, 0, 0, 0, 0, -38, 0, -38, 0, -38, 0, -38, 0, 0, -38, 0, 0,
-        // State 43
-        0, -40, -40, 0, 0, 0, 0, 0, 0, 0, 0, 0, -40, 0, -40, 0, -40, 0, -40, 0, 0, -40, 0, 0,
-        // State 44
-        0, -36, -36, 0, 0, 0, 0, 0, 0, 0, 0, 0, -36, 0, -36, 0, -36, 0, -36, 0, 0, -36, 0, 0,
-        // State 45
-        0, -39, -39, 0, 0, 0, 0, 0, 0, 0, 0, 0, -39, 0, -39, 0, -39, 0, -39, 0, 0, -39, 0, 0,
-        // State 46
-        0, -41, -41, 0, 0, 0, 0, 0, 0, 0, 0, 0, -41, 0, -41, 0, -41, 0, -41, 0, 0, -41, 0, 0,
-        // State 47
-        0, 11, 12, -18, 25, 26, 0, 0, 0, 0, 0, 0, 13, 0, 14, 0, 15, 0, 16, 0, 0, 17, 0, -18,
-        // State 48
-        0, -19, -19, -19, -19, -19, 0, 0, 0, 0, 0, 0, -19, 0, -19, 0, -19, 0, -19, 0, 0, -19, 0, -19,
-        // State 49
-        0, -7, -7, -7, -7, -7, 0, 0, 0, 0, 0, 0, -7, 0, -7, 0, -7, 0, -7, 0, 0, -7, 0, -7,
-        // State 50
-        0, -26, -26, -26, -26, -26, 0, 0, 0, 0, 0, 0, -26, 0, -26, 0, -26, 0, -26, 0, 0, -26, 0, -26,
-        // State 51
-        0, -27, -27, -27, -27, -27, 0, 0, 0, 0, 0, 0, -27, 0, -27, 0, -27, 0, -27, 0, 0, -27, 0, -27,
-        // State 52
-        0, 11, 12, -16, 25, 26, 0, 0, 0, 0, 0, 0, 13, 0, 14, 0, 15, 0, 16, 0, 0, 17, 0, -16,
-        // State 53
-        -24, -24, -24, -24, -24, -24, -24, -24, -24, -24, -24, 0, -24, 0, -24, 0, -24, 0, -24, 0, 0, -24, 0, -24,
-        // State 54
-        -25, -25, -25, -25, -25, -25, -25, -25, -25, -25, -25, 0, -25, 0, -25, 0, -25, 0, -25, 0, 0, -25, 0, -25,
-        // State 55
-        -23, -23, -23, -23, -23, -23, -23, -23, -23, -23, -23, 0, -23, 0, -23, 0, -23, 0, -23, 0, 0, -23, 0, -23,
-        // State 56
         -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, 0, -14, 0, -14, 0, -14, 0, -14, 0, 0, -14, 0, -14,
+        // State 24
+        0, -26, -26, -26, -26, -26, 0, 0, 0, 0, 0, 0, -26, 0, -26, 0, -26, 0, -26, 0, 0, -26, 0, -26,
+        // State 25
+        0, 0, 0, -23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -23,
+        // State 26
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 27
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 28
+        0, 13, 14, -54, 27, 28, 0, 0, 0, 0, 0, 0, 15, 0, 16, 0, 17, 0, 18, 0, 0, 19, 0, -54,
+        // State 29
+        0, 0, 0, -21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -21,
+        // State 30
+        -62, -62, -62, -62, -62, -62, -62, -62, -62, -62, -62, -62, -62, 0, -62, 0, -62, 0, -62, 0, 0, -62, 0, -62,
+        // State 31
+        -28, -28, -28, -28, -28, -28, -28, -28, -28, -28, -28, 59, -28, 0, -28, 0, -28, 0, -28, 0, 0, -28, 0, -28,
+        // State 32
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 33
+        -63, -63, -63, -63, -63, -63, -63, -63, -63, -63, -63, -63, -63, 0, -63, 0, -63, 0, -63, 0, 0, -63, 0, -63,
+        // State 34
+        47, 0, 0, 0, 0, 0, 48, 49, 50, 51, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 35
+        -15, 13, 14, 61, 27, 28, -15, -15, -15, -15, -15, 0, 15, 0, 16, 0, 17, 0, 18, 0, 0, 19, 0, 0,
+        // State 36
+        0, 0, 0, 62, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 37
+        0, 0, 0, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 38
+        -14, 13, 14, 0, 27, 28, -14, -14, -14, -14, -14, 0, 15, 0, 16, 0, 17, 0, 18, 0, 0, 19, 0, 0,
+        // State 39
+        -15, 13, 14, 0, 27, 28, -15, -15, -15, -15, -15, 0, 15, 0, 16, 0, 17, 0, 18, 0, 0, 19, 0, 64,
+        // State 40
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -58,
+        // State 41
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -57,
+        // State 42
+        -14, 13, 14, 0, 27, 28, -14, -14, -14, -14, -14, 0, 15, 0, 16, 0, 17, 0, 18, 0, 0, 19, 0, -56,
+        // State 43
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 65,
+        // State 44
+        0, -59, -59, 0, 0, 0, 0, 0, 0, 0, 0, 0, -59, 0, -59, 0, -59, 0, -59, 0, 0, -59, 0, 0,
+        // State 45
+        0, 13, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 16, 0, 17, 0, 18, 0, 0, 19, 0, 0,
+        // State 46
+        0, -45, -45, 0, 0, 0, 0, 0, 0, 0, 0, 0, -45, 0, -45, 0, -45, 0, -45, 0, 0, -45, 0, 0,
+        // State 47
+        0, -46, -46, 0, 0, 0, 0, 0, 0, 0, 0, 0, -46, 0, -46, 0, -46, 0, -46, 0, 0, -46, 0, 0,
+        // State 48
+        0, -48, -48, 0, 0, 0, 0, 0, 0, 0, 0, 0, -48, 0, -48, 0, -48, 0, -48, 0, 0, -48, 0, 0,
+        // State 49
+        0, -44, -44, 0, 0, 0, 0, 0, 0, 0, 0, 0, -44, 0, -44, 0, -44, 0, -44, 0, 0, -44, 0, 0,
+        // State 50
+        0, -47, -47, 0, 0, 0, 0, 0, 0, 0, 0, 0, -47, 0, -47, 0, -47, 0, -47, 0, 0, -47, 0, 0,
+        // State 51
+        0, -49, -49, 0, 0, 0, 0, 0, 0, 0, 0, 0, -49, 0, -49, 0, -49, 0, -49, 0, 0, -49, 0, 0,
+        // State 52
+        0, 13, 14, -24, 27, 28, 0, 0, 0, 0, 0, 0, 15, 0, 16, 0, 17, 0, 18, 0, 0, 19, 0, -24,
+        // State 53
+        0, -25, -25, -25, -25, -25, 0, 0, 0, 0, 0, 0, -25, 0, -25, 0, -25, 0, -25, 0, 0, -25, 0, -25,
+        // State 54
+        0, -10, -10, -10, -10, -10, 0, 0, 0, 0, 0, 0, -10, 0, -10, 0, -10, 0, -10, 0, 0, -10, 0, -10,
+        // State 55
+        0, -29, -29, -29, -29, -29, 0, 0, 0, 0, 0, 0, -29, 0, -29, 0, -29, 0, -29, 0, 0, -29, 0, -29,
+        // State 56
+        0, -30, -30, -30, -30, -30, 0, 0, 0, 0, 0, 0, -30, 0, -30, 0, -30, 0, -30, 0, 0, -30, 0, -30,
         // State 57
-        -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, 0, -13, 0, -13, 0, -13, 0, -13, 0, 0, -13, 0, -13,
+        0, 13, 14, -22, 27, 28, 0, 0, 0, 0, 0, 0, 15, 0, 16, 0, 17, 0, 18, 0, 0, 19, 0, -22,
         // State 58
-        0, 0, 0, -12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -12,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 59
-        0, -8, -8, -8, -8, -8, 0, 0, 0, 0, 0, 0, -8, 0, -8, 0, -8, 0, -8, 0, 0, -8, 0, -8,
+        -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 0, -2, 0, -2, 0, -2, 0, 0, -2, 0, -2,
+        // State 60
+        -42, -42, -42, -42, -42, -42, -42, -42, -42, -42, -42, -42, -42, 0, -42, 0, -42, 0, -42, 0, 0, -42, 0, -42,
+        // State 61
+        -43, -43, -43, -43, -43, -43, -43, -43, -43, -43, -43, -43, -43, 0, -43, 0, -43, 0, -43, 0, 0, -43, 0, -43,
+        // State 62
+        -41, -41, -41, -41, -41, -41, -41, -41, -41, -41, -41, -41, -41, 0, -41, 0, -41, 0, -41, 0, 0, -41, 0, -41,
+        // State 63
+        -20, -20, -20, -20, -20, -20, -20, -20, -20, -20, -20, -20, -20, 0, -20, 0, -20, 0, -20, 0, 0, -20, 0, -20,
+        // State 64
+        -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, 0, -19, 0, -19, 0, -19, 0, 0, -19, 0, -19,
+        // State 65
+        0, 0, 0, -18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -18,
+        // State 66
+        0, -11, -11, -11, -11, -11, 0, 0, 0, 0, 0, 0, -11, 0, -11, 0, -11, 0, -11, 0, 0, -11, 0, -11,
+        // State 67
+        -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, 0, -3, 0, -3, 0, -3, 0, 0, -3, 0, -3,
     ];
     const __EOF_ACTION: &'static [i8] = &[
         // State 0
         0,
         // State 1
-        0,
+        -17,
         // State 2
-        -22,
-        // State 3
-        -55,
-        // State 4
         0,
+        // State 3
+        -40,
+        // State 4
+        -64,
         // State 5
-        -30,
+        0,
         // State 6
-        -21,
+        -33,
         // State 7
-        -29,
+        -39,
         // State 8
-        -31,
+        -27,
         // State 9
         -32,
         // State 10
-        0,
+        -34,
         // State 11
-        0,
+        -35,
         // State 12
-        -11,
+        0,
         // State 13
-        -52,
+        0,
         // State 14
-        -28,
+        -16,
         // State 15
-        -51,
+        -61,
         // State 16
-        0,
+        -31,
         // State 17
-        -19,
+        -60,
         // State 18
-        -10,
+        0,
         // State 19
-        -47,
+        -25,
         // State 20
-        -46,
-        // State 21
-        -9,
-        // State 22
-        -20,
-        // State 23
-        -17,
-        // State 24
-        0,
-        // State 25
-        0,
-        // State 26
-        -46,
-        // State 27
         -15,
-        // State 28
-        -53,
-        // State 29
+        // State 21
+        -55,
+        // State 22
         -54,
+        // State 23
+        -14,
+        // State 24
+        -26,
+        // State 25
+        -23,
+        // State 26
+        0,
+        // State 27
+        0,
+        // State 28
+        -54,
+        // State 29
+        -21,
         // State 30
-        0,
+        -62,
         // State 31
-        0,
+        -28,
         // State 32
         0,
         // State 33
-        0,
+        -63,
         // State 34
         0,
         // State 35
@@ -256,153 +274,185 @@ mod __parse__Call {
         // State 46
         0,
         // State 47
-        -18,
+        0,
         // State 48
-        -19,
+        0,
         // State 49
-        -7,
+        0,
         // State 50
-        -26,
+        0,
         // State 51
-        -27,
+        0,
         // State 52
-        -16,
-        // State 53
         -24,
-        // State 54
+        // State 53
         -25,
+        // State 54
+        -10,
         // State 55
-        -23,
+        -29,
         // State 56
-        -14,
+        -30,
         // State 57
-        -13,
+        -22,
         // State 58
-        -12,
+        0,
         // State 59
-        -8,
+        -2,
+        // State 60
+        -42,
+        // State 61
+        -43,
+        // State 62
+        -41,
+        // State 63
+        -20,
+        // State 64
+        -19,
+        // State 65
+        -18,
+        // State 66
+        -11,
+        // State 67
+        -3,
     ];
     const __GOTO: &'static [i8] = &[
         // State 0
-        0, 0, 0, 0, 0, 0, 2, 0, 3, 4, 0, 5, 0, 6, 7, 0, 0, 0, 0, 0, 0, 8, 9, 10, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 0, 4, 5, 0, 6, 0, 7, 8, 0, 9, 0, 0, 0, 0, 0, 0, 10, 11, 12, 0, 0,
         // State 1
-        0, 0, 0, 0, 0, 18, 19, 20, 3, 0, 21, 22, 23, 6, 7, 0, 0, 0, 0, 24, 0, 8, 9, 10, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 2
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 2, 21, 22, 4, 0, 23, 24, 25, 7, 8, 0, 9, 0, 0, 0, 26, 0, 0, 10, 11, 12, 0, 0,
         // State 3
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 4
-        0, 0, 0, 0, 0, 18, 19, 20, 3, 0, 27, 22, 23, 6, 7, 0, 0, 0, 0, 28, 0, 8, 9, 10, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 5
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 2, 21, 22, 4, 0, 29, 24, 25, 7, 8, 0, 9, 0, 0, 0, 30, 0, 0, 10, 11, 12, 0, 0,
         // State 6
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 7
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 8
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 9
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 10
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 11
-        0, 0, 0, 0, 0, 31, 32, 33, 3, 34, 0, 35, 0, 6, 7, 0, 0, 0, 0, 0, 0, 8, 9, 10, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 12
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 13
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 35, 2, 36, 37, 4, 38, 0, 39, 0, 7, 8, 0, 9, 0, 0, 0, 0, 0, 0, 10, 11, 12, 0, 0,
         // State 14
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 15
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 16
-        0, 0, 0, 0, 0, 31, 36, 37, 3, 38, 0, 39, 0, 6, 7, 0, 0, 0, 0, 0, 40, 8, 9, 10, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 17
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 18
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 35, 2, 40, 41, 4, 42, 0, 43, 0, 7, 8, 0, 9, 0, 0, 0, 0, 44, 0, 10, 11, 12, 0, 0,
         // State 19
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 45, 0, 0, 0, 0, 46, 0, 0, 0, 0, 0,
         // State 20
-        0, 0, 0, 0, 48, 49, 19, 0, 3, 0, 50, 22, 23, 6, 7, 0, 0, 0, 0, 0, 0, 8, 9, 10, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 21
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 22
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 53, 0, 0, 54, 2, 21, 0, 4, 0, 55, 24, 25, 7, 8, 0, 9, 0, 0, 0, 0, 0, 0, 10, 11, 12, 0, 0,
         // State 23
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 24
-        0, 0, 0, 0, 0, 0, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 25
-        0, 0, 0, 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 26
-        0, 0, 0, 0, 53, 49, 19, 0, 3, 0, 50, 22, 23, 6, 7, 0, 0, 0, 0, 0, 0, 8, 9, 10, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 27
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 57, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 28
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 58, 0, 0, 54, 2, 21, 0, 4, 0, 55, 24, 25, 7, 8, 0, 9, 0, 0, 0, 0, 0, 0, 10, 11, 12, 0, 0,
         // State 29
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 30
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 31
-        0, 0, 0, 0, 0, 18, 19, 20, 3, 0, 21, 22, 23, 6, 7, 0, 0, 0, 0, 24, 0, 8, 9, 10, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 32
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 33
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 34
-        0, 0, 0, 0, 0, 18, 19, 20, 3, 0, 27, 22, 23, 6, 7, 0, 0, 0, 0, 28, 0, 8, 9, 10, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 45, 0, 0, 0, 0, 46, 0, 0, 0, 0, 0,
         // State 35
-        0, 0, 0, 0, 0, 18, 19, 20, 3, 0, 21, 22, 23, 6, 7, 0, 0, 0, 0, 24, 0, 8, 9, 10, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 2, 21, 22, 4, 0, 23, 24, 25, 7, 8, 0, 9, 0, 0, 0, 26, 0, 0, 10, 11, 12, 0, 0,
         // State 36
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 37
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 38
-        0, 0, 0, 0, 0, 18, 19, 20, 3, 0, 27, 22, 23, 6, 7, 0, 0, 0, 0, 28, 0, 8, 9, 10, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 2, 21, 22, 4, 0, 29, 24, 25, 7, 8, 0, 9, 0, 0, 0, 30, 0, 0, 10, 11, 12, 0, 0,
         // State 39
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 2, 21, 22, 4, 0, 23, 24, 25, 7, 8, 0, 9, 0, 0, 0, 26, 0, 0, 10, 11, 12, 0, 0,
         // State 40
-        0, 0, 0, 0, 0, 59, 19, 0, 3, 0, 0, 22, 0, 6, 7, 0, 0, 0, 0, 0, 0, 8, 9, 10, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 41
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 42
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 2, 21, 22, 4, 0, 29, 24, 25, 7, 8, 0, 9, 0, 0, 0, 30, 0, 0, 10, 11, 12, 0, 0,
         // State 43
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 44
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 45
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 66, 2, 21, 0, 4, 0, 0, 24, 0, 7, 8, 0, 9, 0, 0, 0, 0, 0, 0, 10, 11, 12, 0, 0,
         // State 46
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 47
-        0, 0, 0, 0, 0, 49, 19, 0, 3, 0, 60, 22, 23, 6, 7, 0, 0, 0, 0, 0, 0, 8, 9, 10, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 48
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 49
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 50
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 51
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 52
-        0, 0, 0, 0, 0, 49, 19, 0, 3, 0, 60, 22, 23, 6, 7, 0, 0, 0, 0, 0, 0, 8, 9, 10, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 2, 21, 0, 4, 0, 67, 24, 25, 7, 8, 0, 9, 0, 0, 0, 0, 0, 0, 10, 11, 12, 0, 0,
         // State 53
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 54
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 55
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 56
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 57
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 2, 21, 0, 4, 0, 67, 24, 25, 7, 8, 0, 9, 0, 0, 0, 0, 0, 0, 10, 11, 12, 0, 0,
         // State 58
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 59
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 60
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 61
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 62
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 63
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 64
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 65
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 66
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 67
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ];
     fn __expected_tokens(__state: usize) -> Vec<::std::string::String> {
         const __TERMINAL: &'static [&'static str] = &[
@@ -490,7 +540,7 @@ mod __parse__Call {
 
         #[inline]
         fn goto(&self, state: i8, nt: usize) -> i8 {
-            __GOTO[(state as usize) * 26 + nt] - 1
+            __GOTO[(state as usize) * 33 + nt] - 1
         }
 
         fn token_to_symbol(&self, token_index: usize, token: Self::Token) -> Self::Symbol {
@@ -693,13 +743,13 @@ mod __parse__Call {
             }
             1 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 0,
+                    states_to_pop: 2,
                     nonterminal_produced: 1,
                 }
             }
             2 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
+                    states_to_pop: 3,
                     nonterminal_produced: 1,
                 }
             }
@@ -711,8 +761,8 @@ mod __parse__Call {
             }
             4 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 3,
-                    nonterminal_produced: 2,
+                    states_to_pop: 0,
+                    nonterminal_produced: 3,
                 }
             }
             5 => {
@@ -723,13 +773,13 @@ mod __parse__Call {
             }
             6 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
+                    states_to_pop: 2,
                     nonterminal_produced: 4,
                 }
             }
             7 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 2,
+                    states_to_pop: 3,
                     nonterminal_produced: 4,
                 }
             }
@@ -742,280 +792,334 @@ mod __parse__Call {
             9 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 5,
+                    nonterminal_produced: 6,
                 }
             }
             10 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
+                    states_to_pop: 2,
                     nonterminal_produced: 6,
                 }
             }
             11 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 3,
+                    states_to_pop: 0,
                     nonterminal_produced: 7,
                 }
             }
             12 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 3,
+                    states_to_pop: 0,
                     nonterminal_produced: 8,
                 }
             }
             13 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 3,
-                    nonterminal_produced: 8,
+                    states_to_pop: 1,
+                    nonterminal_produced: 9,
                 }
             }
             14 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 2,
+                    states_to_pop: 1,
                     nonterminal_produced: 9,
                 }
             }
             15 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 3,
-                    nonterminal_produced: 9,
+                    states_to_pop: 1,
+                    nonterminal_produced: 10,
                 }
             }
             16 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 2,
-                    nonterminal_produced: 9,
+                    states_to_pop: 1,
+                    nonterminal_produced: 11,
                 }
             }
             17 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 3,
-                    nonterminal_produced: 9,
+                    nonterminal_produced: 12,
                 }
             }
             18 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
-                    nonterminal_produced: 10,
+                    states_to_pop: 3,
+                    nonterminal_produced: 13,
                 }
             }
             19 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
-                    nonterminal_produced: 10,
+                    states_to_pop: 3,
+                    nonterminal_produced: 13,
                 }
             }
             20 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
-                    nonterminal_produced: 11,
+                    states_to_pop: 2,
+                    nonterminal_produced: 14,
                 }
             }
             21 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
-                    nonterminal_produced: 11,
+                    states_to_pop: 3,
+                    nonterminal_produced: 14,
                 }
             }
             22 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 3,
-                    nonterminal_produced: 11,
+                    states_to_pop: 2,
+                    nonterminal_produced: 14,
                 }
             }
             23 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 3,
-                    nonterminal_produced: 11,
+                    nonterminal_produced: 14,
                 }
             }
             24 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 3,
-                    nonterminal_produced: 11,
+                    states_to_pop: 1,
+                    nonterminal_produced: 15,
                 }
             }
             25 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 2,
-                    nonterminal_produced: 12,
+                    states_to_pop: 1,
+                    nonterminal_produced: 15,
                 }
             }
             26 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 2,
-                    nonterminal_produced: 12,
+                    states_to_pop: 1,
+                    nonterminal_produced: 16,
                 }
             }
             27 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
-                    nonterminal_produced: 13,
+                    states_to_pop: 2,
+                    nonterminal_produced: 16,
                 }
             }
             28 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
-                    nonterminal_produced: 14,
+                    states_to_pop: 2,
+                    nonterminal_produced: 17,
                 }
             }
             29 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
-                    nonterminal_produced: 14,
+                    states_to_pop: 2,
+                    nonterminal_produced: 17,
                 }
             }
             30 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 14,
+                    nonterminal_produced: 18,
                 }
             }
             31 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 14,
+                    nonterminal_produced: 19,
                 }
             }
             32 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 15,
+                    nonterminal_produced: 19,
                 }
             }
             33 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 15,
+                    nonterminal_produced: 19,
                 }
             }
             34 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 15,
+                    nonterminal_produced: 19,
                 }
             }
             35 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 16,
+                    nonterminal_produced: 20,
                 }
             }
             36 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 16,
+                    nonterminal_produced: 20,
                 }
             }
             37 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 16,
+                    nonterminal_produced: 20,
                 }
             }
             38 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 16,
+                    nonterminal_produced: 21,
                 }
             }
             39 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 16,
+                    nonterminal_produced: 21,
                 }
             }
             40 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
-                    nonterminal_produced: 16,
+                    states_to_pop: 3,
+                    nonterminal_produced: 21,
                 }
             }
             41 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
-                    nonterminal_produced: 17,
+                    states_to_pop: 3,
+                    nonterminal_produced: 21,
                 }
             }
             42 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 2,
-                    nonterminal_produced: 17,
+                    states_to_pop: 3,
+                    nonterminal_produced: 21,
                 }
             }
             43 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 18,
+                    nonterminal_produced: 22,
                 }
             }
             44 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 18,
+                    nonterminal_produced: 22,
                 }
             }
             45 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 19,
+                    nonterminal_produced: 22,
                 }
             }
             46 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 19,
+                    nonterminal_produced: 22,
                 }
             }
             47 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 20,
+                    nonterminal_produced: 22,
                 }
             }
             48 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 20,
+                    nonterminal_produced: 22,
                 }
             }
             49 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 20,
+                    nonterminal_produced: 23,
                 }
             }
             50 => {
-                __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
-                    nonterminal_produced: 21,
-                }
-            }
-            51 => {
-                __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
-                    nonterminal_produced: 21,
-                }
-            }
-            52 => {
-                __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 2,
-                    nonterminal_produced: 22,
-                }
-            }
-            53 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 2,
                     nonterminal_produced: 23,
                 }
             }
-            54 => __state_machine::SimulatedReduce::Accept,
-            55 => {
+            51 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 1,
+                    nonterminal_produced: 24,
+                }
+            }
+            52 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 1,
+                    nonterminal_produced: 24,
+                }
+            }
+            53 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
                     nonterminal_produced: 25,
                 }
             }
+            54 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 1,
+                    nonterminal_produced: 25,
+                }
+            }
+            55 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 1,
+                    nonterminal_produced: 26,
+                }
+            }
+            56 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 1,
+                    nonterminal_produced: 26,
+                }
+            }
+            57 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 1,
+                    nonterminal_produced: 26,
+                }
+            }
+            58 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 1,
+                    nonterminal_produced: 27,
+                }
+            }
+            59 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 1,
+                    nonterminal_produced: 28,
+                }
+            }
+            60 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 1,
+                    nonterminal_produced: 28,
+                }
+            }
+            61 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 2,
+                    nonterminal_produced: 29,
+                }
+            }
+            62 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 2,
+                    nonterminal_produced: 30,
+                }
+            }
+            63 => __state_machine::SimulatedReduce::Accept,
+            64 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 1,
+                    nonterminal_produced: 32,
+                }
+            }
             _ => panic!("invalid reduction index {}", __reduce_index)
         }
     }
@@ -1225,66 +1329,71 @@ mod __parse__Call {
                 __reduce53(__action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)
             }
             54 => {
+                __reduce54(__action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)
+            }
+            55 => {
+                __reduce55(__action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)
+            }
+            56 => {
+                __reduce56(__action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)
+            }
+            57 => {
+                __reduce57(__action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)
+            }
+            58 => {
+                __reduce58(__action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)
+            }
+            59 => {
+                __reduce59(__action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)
+            }
+            60 => {
+                __reduce60(__action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)
+            }
+            61 => {
+                __reduce61(__action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)
+            }
+            62 => {
+                __reduce62(__action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)
+            }
+            63 => {
                 // __Call = Call => ActionFn(1);
-                let __sym0 = __pop_Variant1(__symbols);
+                let __sym0 = __pop_Variant2(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym0.2.clone();
                 let __nt = super::__action1::<>(__sym0);
                 return Some(Ok(__nt));
             }
-            55 => {
-                __reduce55(__action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)
+            64 => {
+                __reduce64(__action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)
             }
             _ => panic!("invalid action code {}", __action)
         };
         let __states_len = __states.len();
         __states.truncate(__states_len - __pop_states);
         let __state = *__states.last().unwrap() as usize;
-        let __next_state = __GOTO[__state * 26 + __nonterminal] - 1;
+        let __next_state = __GOTO[__state * 33 + __nonterminal] - 1;
         __states.push(__next_state);
         None
     }
-    fn __pop_Variant3<
+    fn __pop_Variant5<
       'input,
     >(
         __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
-    ) -> (usize, BarePath, usize)
+    ) -> (usize, Bare, usize)
      {
         match __symbols.pop().unwrap() {
-            (__l, __Symbol::Variant3(__v), __r) => (__l, __v, __r),
+            (__l, __Symbol::Variant5(__v), __r) => (__l, __v, __r),
             _ => panic!("symbol type mismatch")
         }
     }
-    fn __pop_Variant1<
+    fn __pop_Variant2<
       'input,
     >(
         __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
     ) -> (usize, Expression, usize)
      {
         match __symbols.pop().unwrap() {
-            (__l, __Symbol::Variant1(__v), __r) => (__l, __v, __r),
-            _ => panic!("symbol type mismatch")
-        }
-    }
-    fn __pop_Variant4<
-      'input,
-    >(
-        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
-    ) -> (usize, Flag, usize)
-     {
-        match __symbols.pop().unwrap() {
-            (__l, __Symbol::Variant4(__v), __r) => (__l, __v, __r),
-            _ => panic!("symbol type mismatch")
-        }
-    }
-    fn __pop_Variant7<
-      'input,
-    >(
-        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
-    ) -> (usize, Operator, usize)
-     {
-        match __symbols.pop().unwrap() {
-            (__l, __Symbol::Variant7(__v), __r) => (__l, __v, __r),
+            (__l, __Symbol::Variant2(__v), __r) => (__l, __v, __r),
             _ => panic!("symbol type mismatch")
         }
     }
@@ -1292,13 +1401,35 @@ mod __parse__Call {
       'input,
     >(
         __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
-    ) -> (usize, Pipeline, usize)
+    ) -> (usize, Operator, usize)
      {
         match __symbols.pop().unwrap() {
             (__l, __Symbol::Variant8(__v), __r) => (__l, __v, __r),
             _ => panic!("symbol type mismatch")
         }
     }
+    fn __pop_Variant9<
+      'input,
+    >(
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, Pipeline, usize)
+     {
+        match __symbols.pop().unwrap() {
+            (__l, __Symbol::Variant9(__v), __r) => (__l, __v, __r),
+            _ => panic!("symbol type mismatch")
+        }
+    }
+    fn __pop_Variant10<
+      'input,
+    >(
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, Spanned<Operator>, usize)
+     {
+        match __symbols.pop().unwrap() {
+            (__l, __Symbol::Variant10(__v), __r) => (__l, __v, __r),
+            _ => panic!("symbol type mismatch")
+        }
+    }
     fn __pop_Variant0<
       'input,
     >(
@@ -1310,36 +1441,58 @@ mod __parse__Call {
             _ => panic!("symbol type mismatch")
         }
     }
-    fn __pop_Variant6<
+    fn __pop_Variant7<
       'input,
     >(
         __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
     ) -> (usize, String, usize)
      {
         match __symbols.pop().unwrap() {
-            (__l, __Symbol::Variant6(__v), __r) => (__l, __v, __r),
+            (__l, __Symbol::Variant7(__v), __r) => (__l, __v, __r),
             _ => panic!("symbol type mismatch")
         }
     }
-    fn __pop_Variant5<
+    fn __pop_Variant6<
       'input,
     >(
         __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
     ) -> (usize, i64, usize)
      {
         match __symbols.pop().unwrap() {
-            (__l, __Symbol::Variant5(__v), __r) => (__l, __v, __r),
+            (__l, __Symbol::Variant6(__v), __r) => (__l, __v, __r),
             _ => panic!("symbol type mismatch")
         }
     }
-    fn __pop_Variant2<
+    fn __pop_Variant4<
+      'input,
+    >(
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, usize, usize)
+     {
+        match __symbols.pop().unwrap() {
+            (__l, __Symbol::Variant4(__v), __r) => (__l, __v, __r),
+            _ => panic!("symbol type mismatch")
+        }
+    }
+    fn __pop_Variant3<
       'input,
     >(
         __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
     ) -> (usize, ::std::vec::Vec<Expression>, usize)
      {
         match __symbols.pop().unwrap() {
-            (__l, __Symbol::Variant2(__v), __r) => (__l, __v, __r),
+            (__l, __Symbol::Variant3(__v), __r) => (__l, __v, __r),
+            _ => panic!("symbol type mismatch")
+        }
+    }
+    fn __pop_Variant1<
+      'input,
+    >(
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, ::std::vec::Vec<SpannedToken<'input>>, usize)
+     {
+        match __symbols.pop().unwrap() {
+            (__l, __Symbol::Variant1(__v), __r) => (__l, __v, __r),
             _ => panic!("symbol type mismatch")
         }
     }
@@ -1353,13 +1506,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // ("|" <PipelineElement>) = "|", PipelineElement => ActionFn(52);
-        let __sym1 = __pop_Variant1(__symbols);
+        // ("???." <"member">) = "???.", "member" => ActionFn(53);
+        let __sym1 = __pop_Variant0(__symbols);
         let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym1.2.clone();
-        let __nt = super::__action52::<>(__sym0, __sym1);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
+        let __nt = super::__action53::<>(__sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant0(__nt), __end));
         (2, 0)
     }
     pub(crate) fn __reduce1<
@@ -1372,12 +1525,14 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // ("|" <PipelineElement>)* =  => ActionFn(50);
-        let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();
-        let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());
-        let __nt = super::__action50::<>(&__start, &__end);
-        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
-        (0, 1)
+        // ("???." <"member">)+ = "???.", "member" => ActionFn(64);
+        let __sym1 = __pop_Variant0(__symbols);
+        let __sym0 = __pop_Variant0(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym1.2.clone();
+        let __nt = super::__action64::<>(__sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
+        (2, 1)
     }
     pub(crate) fn __reduce2<
         'input,
@@ -1389,13 +1544,15 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // ("|" <PipelineElement>)* = ("|" <PipelineElement>)+ => ActionFn(51);
-        let __sym0 = __pop_Variant2(__symbols);
+        // ("???." <"member">)+ = ("???." <"member">)+, "???.", "member" => ActionFn(65);
+        let __sym2 = __pop_Variant0(__symbols);
+        let __sym1 = __pop_Variant0(__symbols);
+        let __sym0 = __pop_Variant1(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action51::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
-        (1, 1)
+        let __end = __sym2.2.clone();
+        let __nt = super::__action65::<>(__sym0, __sym1, __sym2);
+        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
+        (3, 1)
     }
     pub(crate) fn __reduce3<
         'input,
@@ -1407,12 +1564,12 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // ("|" <PipelineElement>)+ = "|", PipelineElement => ActionFn(55);
-        let __sym1 = __pop_Variant1(__symbols);
+        // ("|" <PipelineElement>) = "|", PipelineElement => ActionFn(60);
+        let __sym1 = __pop_Variant2(__symbols);
         let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym1.2.clone();
-        let __nt = super::__action55::<>(__sym0, __sym1);
+        let __nt = super::__action60::<>(__sym0, __sym1);
         __symbols.push((__start, __Symbol::Variant2(__nt), __end));
         (2, 2)
     }
@@ -1426,15 +1583,12 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // ("|" <PipelineElement>)+ = ("|" <PipelineElement>)+, "|", PipelineElement => ActionFn(56);
-        let __sym2 = __pop_Variant1(__symbols);
-        let __sym1 = __pop_Variant0(__symbols);
-        let __sym0 = __pop_Variant2(__symbols);
-        let __start = __sym0.0.clone();
-        let __end = __sym2.2.clone();
-        let __nt = super::__action56::<>(__sym0, __sym1, __sym2);
-        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
-        (3, 2)
+        // ("|" <PipelineElement>)* =  => ActionFn(58);
+        let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();
+        let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());
+        let __nt = super::__action58::<>(&__start, &__end);
+        __symbols.push((__start, __Symbol::Variant3(__nt), __end));
+        (0, 3)
     }
     pub(crate) fn __reduce5<
         'input,
@@ -1446,12 +1600,12 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // (<CallArgument>) = CallArgument => ActionFn(49);
-        let __sym0 = __pop_Variant1(__symbols);
+        // ("|" <PipelineElement>)* = ("|" <PipelineElement>)+ => ActionFn(59);
+        let __sym0 = __pop_Variant3(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action49::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
+        let __nt = super::__action59::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant3(__nt), __end));
         (1, 3)
     }
     pub(crate) fn __reduce6<
@@ -1464,13 +1618,14 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // (<CallArgument>)+ = CallArgument => ActionFn(59);
-        let __sym0 = __pop_Variant1(__symbols);
+        // ("|" <PipelineElement>)+ = "|", PipelineElement => ActionFn(66);
+        let __sym1 = __pop_Variant2(__symbols);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action59::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
-        (1, 4)
+        let __end = __sym1.2.clone();
+        let __nt = super::__action66::<>(__sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant3(__nt), __end));
+        (2, 4)
     }
     pub(crate) fn __reduce7<
         'input,
@@ -1482,14 +1637,15 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // (<CallArgument>)+ = (<CallArgument>)+, CallArgument => ActionFn(60);
-        let __sym1 = __pop_Variant1(__symbols);
-        let __sym0 = __pop_Variant2(__symbols);
+        // ("|" <PipelineElement>)+ = ("|" <PipelineElement>)+, "|", PipelineElement => ActionFn(67);
+        let __sym2 = __pop_Variant2(__symbols);
+        let __sym1 = __pop_Variant0(__symbols);
+        let __sym0 = __pop_Variant3(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym1.2.clone();
-        let __nt = super::__action60::<>(__sym0, __sym1);
-        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
-        (2, 4)
+        let __end = __sym2.2.clone();
+        let __nt = super::__action67::<>(__sym0, __sym1, __sym2);
+        __symbols.push((__start, __Symbol::Variant3(__nt), __end));
+        (3, 4)
     }
     pub(crate) fn __reduce8<
         'input,
@@ -1501,12 +1657,12 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // ArgumentExpression = Expression => ActionFn(21);
-        let __sym0 = __pop_Variant1(__symbols);
+        // (<CallArgument>) = CallArgument => ActionFn(56);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action21::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
+        let __nt = super::__action56::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
         (1, 5)
     }
     pub(crate) fn __reduce9<
@@ -1519,13 +1675,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // ArgumentExpression = Bare => ActionFn(22);
-        let __sym0 = __pop_Variant3(__symbols);
+        // (<CallArgument>)+ = CallArgument => ActionFn(70);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action22::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 5)
+        let __nt = super::__action70::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant3(__nt), __end));
+        (1, 6)
     }
     pub(crate) fn __reduce10<
         'input,
@@ -1537,13 +1693,14 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Bare = "bare" => ActionFn(30);
-        let __sym0 = __pop_Variant0(__symbols);
+        // (<CallArgument>)+ = (<CallArgument>)+, CallArgument => ActionFn(71);
+        let __sym1 = __pop_Variant2(__symbols);
+        let __sym0 = __pop_Variant3(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action30::<>(__sym0);
+        let __end = __sym1.2.clone();
+        let __nt = super::__action71::<>(__sym0, __sym1);
         __symbols.push((__start, __Symbol::Variant3(__nt), __end));
-        (1, 6)
+        (2, 6)
     }
     pub(crate) fn __reduce11<
         'input,
@@ -1555,15 +1712,12 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Binary = ArgumentExpression, Operator, ArgumentExpression => ActionFn(13);
-        let __sym2 = __pop_Variant1(__symbols);
-        let __sym1 = __pop_Variant7(__symbols);
-        let __sym0 = __pop_Variant1(__symbols);
-        let __start = __sym0.0.clone();
-        let __end = __sym2.2.clone();
-        let __nt = super::__action13::<>(__sym0, __sym1, __sym2);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (3, 7)
+        // @L =  => ActionFn(61);
+        let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();
+        let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());
+        let __nt = super::__action61::<>(&__start, &__end);
+        __symbols.push((__start, __Symbol::Variant4(__nt), __end));
+        (0, 7)
     }
     pub(crate) fn __reduce12<
         'input,
@@ -1575,15 +1729,12 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Block = "{", SingleExpression, "}" => ActionFn(14);
-        let __sym2 = __pop_Variant0(__symbols);
-        let __sym1 = __pop_Variant1(__symbols);
-        let __sym0 = __pop_Variant0(__symbols);
-        let __start = __sym0.0.clone();
-        let __end = __sym2.2.clone();
-        let __nt = super::__action14::<>(__sym0, __sym1, __sym2);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (3, 8)
+        // @R =  => ActionFn(57);
+        let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();
+        let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());
+        let __nt = super::__action57::<>(&__start, &__end);
+        __symbols.push((__start, __Symbol::Variant4(__nt), __end));
+        (0, 8)
     }
     pub(crate) fn __reduce13<
         'input,
@@ -1595,15 +1746,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Block = "{", Bare, "}" => ActionFn(15);
-        let __sym2 = __pop_Variant0(__symbols);
-        let __sym1 = __pop_Variant3(__symbols);
-        let __sym0 = __pop_Variant0(__symbols);
+        // ArgumentExpression = Expression => ActionFn(23);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym2.2.clone();
-        let __nt = super::__action15::<>(__sym0, __sym1, __sym2);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (3, 8)
+        let __end = __sym0.2.clone();
+        let __nt = super::__action23::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 9)
     }
     pub(crate) fn __reduce14<
         'input,
@@ -1615,14 +1764,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Call = Expression, SingleCallArgument => ActionFn(9);
-        let __sym1 = __pop_Variant1(__symbols);
-        let __sym0 = __pop_Variant1(__symbols);
+        // ArgumentExpression = BareExpression => ActionFn(24);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym1.2.clone();
-        let __nt = super::__action9::<>(__sym0, __sym1);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (2, 9)
+        let __end = __sym0.2.clone();
+        let __nt = super::__action24::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 9)
     }
     pub(crate) fn __reduce15<
         'input,
@@ -1634,15 +1782,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Call = Expression, CallArgument, (<CallArgument>)+ => ActionFn(10);
-        let __sym2 = __pop_Variant2(__symbols);
-        let __sym1 = __pop_Variant1(__symbols);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Bare = "bare" => ActionFn(34);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym2.2.clone();
-        let __nt = super::__action10::<>(__sym0, __sym1, __sym2);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (3, 9)
+        let __end = __sym0.2.clone();
+        let __nt = super::__action34::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant5(__nt), __end));
+        (1, 10)
     }
     pub(crate) fn __reduce16<
         'input,
@@ -1654,14 +1800,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Call = Bare, SingleCallArgument => ActionFn(11);
-        let __sym1 = __pop_Variant1(__symbols);
-        let __sym0 = __pop_Variant3(__symbols);
+        // BareExpression = Bare => ActionFn(95);
+        let __sym0 = __pop_Variant5(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym1.2.clone();
-        let __nt = super::__action11::<>(__sym0, __sym1);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (2, 9)
+        let __end = __sym0.2.clone();
+        let __nt = super::__action95::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 11)
     }
     pub(crate) fn __reduce17<
         'input,
@@ -1673,15 +1818,15 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Call = Bare, CallArgument, (<CallArgument>)+ => ActionFn(12);
+        // Binary = ArgumentExpression, SpannedOperator, ArgumentExpression => ActionFn(96);
         let __sym2 = __pop_Variant2(__symbols);
-        let __sym1 = __pop_Variant1(__symbols);
-        let __sym0 = __pop_Variant3(__symbols);
+        let __sym1 = __pop_Variant10(__symbols);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym2.2.clone();
-        let __nt = super::__action12::<>(__sym0, __sym1, __sym2);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (3, 9)
+        let __nt = super::__action96::<>(__sym0, __sym1, __sym2);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (3, 12)
     }
     pub(crate) fn __reduce18<
         'input,
@@ -1693,13 +1838,15 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // CallArgument = ArgumentExpression => ActionFn(23);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Block = "{", SingleExpression, "}" => ActionFn(97);
+        let __sym2 = __pop_Variant0(__symbols);
+        let __sym1 = __pop_Variant2(__symbols);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action23::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 10)
+        let __end = __sym2.2.clone();
+        let __nt = super::__action97::<>(__sym0, __sym1, __sym2);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (3, 13)
     }
     pub(crate) fn __reduce19<
         'input,
@@ -1711,13 +1858,15 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // CallArgument = Flag => ActionFn(24);
-        let __sym0 = __pop_Variant4(__symbols);
+        // Block = "{", BareExpression, "}" => ActionFn(98);
+        let __sym2 = __pop_Variant0(__symbols);
+        let __sym1 = __pop_Variant2(__symbols);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action24::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 10)
+        let __end = __sym2.2.clone();
+        let __nt = super::__action98::<>(__sym0, __sym1, __sym2);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (3, 13)
     }
     pub(crate) fn __reduce20<
         'input,
@@ -1729,13 +1878,14 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Expression = LeafExpression => ActionFn(16);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Call = Expression, SingleCallArgument => ActionFn(99);
+        let __sym1 = __pop_Variant2(__symbols);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action16::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 11)
+        let __end = __sym1.2.clone();
+        let __nt = super::__action99::<>(__sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (2, 14)
     }
     pub(crate) fn __reduce21<
         'input,
@@ -1747,13 +1897,15 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Expression = Block => ActionFn(17);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Call = Expression, CallArgument, (<CallArgument>)+ => ActionFn(100);
+        let __sym2 = __pop_Variant3(__symbols);
+        let __sym1 = __pop_Variant2(__symbols);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action17::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 11)
+        let __end = __sym2.2.clone();
+        let __nt = super::__action100::<>(__sym0, __sym1, __sym2);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (3, 14)
     }
     pub(crate) fn __reduce22<
         'input,
@@ -1765,15 +1917,14 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Expression = "(", Call, ")" => ActionFn(18);
-        let __sym2 = __pop_Variant0(__symbols);
-        let __sym1 = __pop_Variant1(__symbols);
-        let __sym0 = __pop_Variant0(__symbols);
+        // Call = BareExpression, SingleCallArgument => ActionFn(101);
+        let __sym1 = __pop_Variant2(__symbols);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym2.2.clone();
-        let __nt = super::__action18::<>(__sym0, __sym1, __sym2);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (3, 11)
+        let __end = __sym1.2.clone();
+        let __nt = super::__action101::<>(__sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (2, 14)
     }
     pub(crate) fn __reduce23<
         'input,
@@ -1785,15 +1936,15 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Expression = "(", Bare, ")" => ActionFn(19);
-        let __sym2 = __pop_Variant0(__symbols);
-        let __sym1 = __pop_Variant3(__symbols);
-        let __sym0 = __pop_Variant0(__symbols);
+        // Call = BareExpression, CallArgument, (<CallArgument>)+ => ActionFn(102);
+        let __sym2 = __pop_Variant3(__symbols);
+        let __sym1 = __pop_Variant2(__symbols);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym2.2.clone();
-        let __nt = super::__action19::<>(__sym0, __sym1, __sym2);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (3, 11)
+        let __nt = super::__action102::<>(__sym0, __sym1, __sym2);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (3, 14)
     }
     pub(crate) fn __reduce24<
         'input,
@@ -1805,15 +1956,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Expression = "(", Binary, ")" => ActionFn(20);
-        let __sym2 = __pop_Variant0(__symbols);
-        let __sym1 = __pop_Variant1(__symbols);
-        let __sym0 = __pop_Variant0(__symbols);
+        // CallArgument = ArgumentExpression => ActionFn(25);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym2.2.clone();
-        let __nt = super::__action20::<>(__sym0, __sym1, __sym2);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (3, 11)
+        let __end = __sym0.2.clone();
+        let __nt = super::__action25::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 15)
     }
     pub(crate) fn __reduce25<
         'input,
@@ -1825,14 +1974,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Flag = "-", Bare => ActionFn(44);
-        let __sym1 = __pop_Variant3(__symbols);
-        let __sym0 = __pop_Variant0(__symbols);
+        // CallArgument = Flag => ActionFn(26);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym1.2.clone();
-        let __nt = super::__action44::<>(__sym0, __sym1);
-        __symbols.push((__start, __Symbol::Variant4(__nt), __end));
-        (2, 12)
+        let __end = __sym0.2.clone();
+        let __nt = super::__action26::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 15)
     }
     pub(crate) fn __reduce26<
         'input,
@@ -1844,14 +1992,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Flag = "--", Bare => ActionFn(45);
-        let __sym1 = __pop_Variant3(__symbols);
-        let __sym0 = __pop_Variant0(__symbols);
+        // Expression = MemberHeadExpression => ActionFn(21);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym1.2.clone();
-        let __nt = super::__action45::<>(__sym0, __sym1);
-        __symbols.push((__start, __Symbol::Variant4(__nt), __end));
-        (2, 12)
+        let __end = __sym0.2.clone();
+        let __nt = super::__action21::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 16)
     }
     pub(crate) fn __reduce27<
         'input,
@@ -1863,13 +2010,14 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Int = "num" => ActionFn(40);
-        let __sym0 = __pop_Variant0(__symbols);
+        // Expression = MemberHeadExpression, ("???." <"member">)+ => ActionFn(103);
+        let __sym1 = __pop_Variant1(__symbols);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action40::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant5(__nt), __end));
-        (1, 13)
+        let __end = __sym1.2.clone();
+        let __nt = super::__action103::<>(__sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (2, 16)
     }
     pub(crate) fn __reduce28<
         'input,
@@ -1881,13 +2029,14 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // LeafExpression = String => ActionFn(5);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Flag = "-", Bare => ActionFn(104);
+        let __sym1 = __pop_Variant5(__symbols);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action5::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 14)
+        let __end = __sym1.2.clone();
+        let __nt = super::__action104::<>(__sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (2, 17)
     }
     pub(crate) fn __reduce29<
         'input,
@@ -1899,13 +2048,14 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // LeafExpression = Int => ActionFn(6);
-        let __sym0 = __pop_Variant5(__symbols);
+        // Flag = "--", Bare => ActionFn(105);
+        let __sym1 = __pop_Variant5(__symbols);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action6::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 14)
+        let __end = __sym1.2.clone();
+        let __nt = super::__action105::<>(__sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (2, 17)
     }
     pub(crate) fn __reduce30<
         'input,
@@ -1917,13 +2067,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // LeafExpression = UnitsNum => ActionFn(7);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Int = "num" => ActionFn(44);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action7::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 14)
+        let __nt = super::__action44::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant6(__nt), __end));
+        (1, 18)
     }
     pub(crate) fn __reduce31<
         'input,
@@ -1935,13 +2085,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // LeafExpression = Var => ActionFn(8);
-        let __sym0 = __pop_Variant1(__symbols);
+        // LeafExpression = String => ActionFn(5);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action8::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 14)
+        let __nt = super::__action5::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 19)
     }
     pub(crate) fn __reduce32<
         'input,
@@ -1953,13 +2103,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Member = "member" => ActionFn(31);
-        let __sym0 = __pop_Variant0(__symbols);
+        // LeafExpression = Int => ActionFn(106);
+        let __sym0 = __pop_Variant6(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action31::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant6(__nt), __end));
-        (1, 15)
+        let __nt = super::__action106::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 19)
     }
     pub(crate) fn __reduce33<
         'input,
@@ -1971,13 +2121,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Member = "dqmember" => ActionFn(32);
-        let __sym0 = __pop_Variant0(__symbols);
+        // LeafExpression = UnitsNum => ActionFn(7);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action32::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant6(__nt), __end));
-        (1, 15)
+        let __nt = super::__action7::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 19)
     }
     pub(crate) fn __reduce34<
         'input,
@@ -1989,13 +2139,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Member = "sqmember" => ActionFn(33);
-        let __sym0 = __pop_Variant0(__symbols);
+        // LeafExpression = Var => ActionFn(8);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action33::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant6(__nt), __end));
-        (1, 15)
+        let __nt = super::__action8::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 19)
     }
     pub(crate) fn __reduce35<
         'input,
@@ -2007,13 +2157,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Operator = "==" => ActionFn(34);
+        // Member = "member" => ActionFn(35);
         let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action34::<>(__sym0);
+        let __nt = super::__action35::<>(__sym0);
         __symbols.push((__start, __Symbol::Variant7(__nt), __end));
-        (1, 16)
+        (1, 20)
     }
     pub(crate) fn __reduce36<
         'input,
@@ -2025,13 +2175,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Operator = "!=" => ActionFn(35);
+        // Member = "dqmember" => ActionFn(36);
         let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action35::<>(__sym0);
+        let __nt = super::__action36::<>(__sym0);
         __symbols.push((__start, __Symbol::Variant7(__nt), __end));
-        (1, 16)
+        (1, 20)
     }
     pub(crate) fn __reduce37<
         'input,
@@ -2043,13 +2193,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Operator = "<" => ActionFn(36);
+        // Member = "sqmember" => ActionFn(37);
         let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action36::<>(__sym0);
+        let __nt = super::__action37::<>(__sym0);
         __symbols.push((__start, __Symbol::Variant7(__nt), __end));
-        (1, 16)
+        (1, 20)
     }
     pub(crate) fn __reduce38<
         'input,
@@ -2061,13 +2211,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Operator = ">" => ActionFn(37);
-        let __sym0 = __pop_Variant0(__symbols);
+        // MemberHeadExpression = LeafExpression => ActionFn(16);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action37::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant7(__nt), __end));
-        (1, 16)
+        let __nt = super::__action16::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 21)
     }
     pub(crate) fn __reduce39<
         'input,
@@ -2079,13 +2229,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Operator = "<=" => ActionFn(38);
-        let __sym0 = __pop_Variant0(__symbols);
+        // MemberHeadExpression = Block => ActionFn(17);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action38::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant7(__nt), __end));
-        (1, 16)
+        let __nt = super::__action17::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 21)
     }
     pub(crate) fn __reduce40<
         'input,
@@ -2097,13 +2247,15 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Operator = ">=" => ActionFn(39);
+        // MemberHeadExpression = "(", Call, ")" => ActionFn(107);
+        let __sym2 = __pop_Variant0(__symbols);
+        let __sym1 = __pop_Variant2(__symbols);
         let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action39::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant7(__nt), __end));
-        (1, 16)
+        let __end = __sym2.2.clone();
+        let __nt = super::__action107::<>(__sym0, __sym1, __sym2);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (3, 21)
     }
     pub(crate) fn __reduce41<
         'input,
@@ -2115,13 +2267,15 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Pipeline = PipelineElement => ActionFn(57);
-        let __sym0 = __pop_Variant1(__symbols);
+        // MemberHeadExpression = "(", BareExpression, ")" => ActionFn(108);
+        let __sym2 = __pop_Variant0(__symbols);
+        let __sym1 = __pop_Variant2(__symbols);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action57::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant8(__nt), __end));
-        (1, 17)
+        let __end = __sym2.2.clone();
+        let __nt = super::__action108::<>(__sym0, __sym1, __sym2);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (3, 21)
     }
     pub(crate) fn __reduce42<
         'input,
@@ -2133,14 +2287,15 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Pipeline = PipelineElement, ("|" <PipelineElement>)+ => ActionFn(58);
+        // MemberHeadExpression = "(", Binary, ")" => ActionFn(109);
+        let __sym2 = __pop_Variant0(__symbols);
         let __sym1 = __pop_Variant2(__symbols);
-        let __sym0 = __pop_Variant1(__symbols);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym1.2.clone();
-        let __nt = super::__action58::<>(__sym0, __sym1);
-        __symbols.push((__start, __Symbol::Variant8(__nt), __end));
-        (2, 17)
+        let __end = __sym2.2.clone();
+        let __nt = super::__action109::<>(__sym0, __sym1, __sym2);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (3, 21)
     }
     pub(crate) fn __reduce43<
         'input,
@@ -2152,13 +2307,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // PipelineElement = Bare => ActionFn(3);
-        let __sym0 = __pop_Variant3(__symbols);
+        // Operator = "==" => ActionFn(38);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action3::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 18)
+        let __nt = super::__action38::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant8(__nt), __end));
+        (1, 22)
     }
     pub(crate) fn __reduce44<
         'input,
@@ -2170,13 +2325,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // PipelineElement = SingleExpression => ActionFn(4);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Operator = "!=" => ActionFn(39);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action4::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 18)
+        let __nt = super::__action39::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant8(__nt), __end));
+        (1, 22)
     }
     pub(crate) fn __reduce45<
         'input,
@@ -2188,13 +2343,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // SingleCallArgument = CallArgument => ActionFn(25);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Operator = "<" => ActionFn(40);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action25::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 19)
+        let __nt = super::__action40::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant8(__nt), __end));
+        (1, 22)
     }
     pub(crate) fn __reduce46<
         'input,
@@ -2206,13 +2361,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // SingleCallArgument = Binary => ActionFn(26);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Operator = ">" => ActionFn(41);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action26::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 19)
+        let __nt = super::__action41::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant8(__nt), __end));
+        (1, 22)
     }
     pub(crate) fn __reduce47<
         'input,
@@ -2224,13 +2379,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // SingleExpression = Expression => ActionFn(27);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Operator = "<=" => ActionFn(42);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action27::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 20)
+        let __nt = super::__action42::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant8(__nt), __end));
+        (1, 22)
     }
     pub(crate) fn __reduce48<
         'input,
@@ -2242,13 +2397,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // SingleExpression = Call => ActionFn(28);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Operator = ">=" => ActionFn(43);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action28::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 20)
+        let __nt = super::__action43::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant8(__nt), __end));
+        (1, 22)
     }
     pub(crate) fn __reduce49<
         'input,
@@ -2260,13 +2415,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // SingleExpression = Binary => ActionFn(29);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Pipeline = PipelineElement => ActionFn(110);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action29::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 20)
+        let __nt = super::__action110::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant9(__nt), __end));
+        (1, 23)
     }
     pub(crate) fn __reduce50<
         'input,
@@ -2278,13 +2433,14 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // String = "sqstring" => ActionFn(42);
-        let __sym0 = __pop_Variant0(__symbols);
+        // Pipeline = PipelineElement, ("|" <PipelineElement>)+ => ActionFn(111);
+        let __sym1 = __pop_Variant3(__symbols);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action42::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 21)
+        let __end = __sym1.2.clone();
+        let __nt = super::__action111::<>(__sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant9(__nt), __end));
+        (2, 23)
     }
     pub(crate) fn __reduce51<
         'input,
@@ -2296,13 +2452,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // String = "dqstring" => ActionFn(43);
-        let __sym0 = __pop_Variant0(__symbols);
+        // PipelineElement = BareExpression => ActionFn(112);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action43::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 21)
+        let __nt = super::__action112::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 24)
     }
     pub(crate) fn __reduce52<
         'input,
@@ -2314,14 +2470,13 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // UnitsNum = Int, "unit" => ActionFn(41);
-        let __sym1 = __pop_Variant0(__symbols);
-        let __sym0 = __pop_Variant5(__symbols);
+        // PipelineElement = SingleExpression => ActionFn(4);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym1.2.clone();
-        let __nt = super::__action41::<>(__sym0, __sym1);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (2, 22)
+        let __end = __sym0.2.clone();
+        let __nt = super::__action4::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 24)
     }
     pub(crate) fn __reduce53<
         'input,
@@ -2333,14 +2488,31 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Var = "$", "variable" => ActionFn(46);
-        let __sym1 = __pop_Variant0(__symbols);
-        let __sym0 = __pop_Variant0(__symbols);
+        // SingleCallArgument = CallArgument => ActionFn(27);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym1.2.clone();
-        let __nt = super::__action46::<>(__sym0, __sym1);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (2, 23)
+        let __end = __sym0.2.clone();
+        let __nt = super::__action27::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 25)
+    }
+    pub(crate) fn __reduce54<
+        'input,
+    >(
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // SingleCallArgument = Binary => ActionFn(28);
+        let __sym0 = __pop_Variant2(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action28::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 25)
     }
     pub(crate) fn __reduce55<
         'input,
@@ -2352,13 +2524,159 @@ mod __parse__Call {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // __Pipeline = Pipeline => ActionFn(0);
+        // SingleExpression = Expression => ActionFn(29);
+        let __sym0 = __pop_Variant2(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action29::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 26)
+    }
+    pub(crate) fn __reduce56<
+        'input,
+    >(
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // SingleExpression = Call => ActionFn(30);
+        let __sym0 = __pop_Variant2(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action30::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 26)
+    }
+    pub(crate) fn __reduce57<
+        'input,
+    >(
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // SingleExpression = Binary => ActionFn(31);
+        let __sym0 = __pop_Variant2(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action31::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 26)
+    }
+    pub(crate) fn __reduce58<
+        'input,
+    >(
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // SpannedOperator = Operator => ActionFn(113);
         let __sym0 = __pop_Variant8(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
+        let __nt = super::__action113::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant10(__nt), __end));
+        (1, 27)
+    }
+    pub(crate) fn __reduce59<
+        'input,
+    >(
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // String = "sqstring" => ActionFn(114);
+        let __sym0 = __pop_Variant0(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action114::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 28)
+    }
+    pub(crate) fn __reduce60<
+        'input,
+    >(
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // String = "dqstring" => ActionFn(115);
+        let __sym0 = __pop_Variant0(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action115::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 28)
+    }
+    pub(crate) fn __reduce61<
+        'input,
+    >(
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // UnitsNum = Int, "unit" => ActionFn(116);
+        let __sym1 = __pop_Variant0(__symbols);
+        let __sym0 = __pop_Variant6(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym1.2.clone();
+        let __nt = super::__action116::<>(__sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (2, 29)
+    }
+    pub(crate) fn __reduce62<
+        'input,
+    >(
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // Var = "$", "variable" => ActionFn(117);
+        let __sym1 = __pop_Variant0(__symbols);
+        let __sym0 = __pop_Variant0(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym1.2.clone();
+        let __nt = super::__action117::<>(__sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (2, 30)
+    }
+    pub(crate) fn __reduce64<
+        'input,
+    >(
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // __Pipeline = Pipeline => ActionFn(0);
+        let __sym0 = __pop_Variant9(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
         let __nt = super::__action0::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant8(__nt), __end));
-        (1, 25)
+        __symbols.push((__start, __Symbol::Variant9(__nt), __end));
+        (1, 32)
     }
 }
 pub use self::__parse__Call::CallParser;
@@ -2370,7 +2688,7 @@ mod __parse__Pipeline {
     use std::str::FromStr;
     use crate::parser::ast::*;
     use crate::prelude::*;
-    use crate::parser::lexer::{SpannedToken, Token};
+    use crate::parser::lexer::{SpannedToken, Spanned, Span, Token};
     use byte_unit::Byte;
     #[allow(unused_extern_crates)]
     extern crate lalrpop_util as __lalrpop_util;
@@ -2381,148 +2699,166 @@ mod __parse__Pipeline {
     pub enum __Symbol<'input>
      {
         Variant0(SpannedToken<'input>),
-        Variant1(Expression),
-        Variant2(::std::vec::Vec<Expression>),
-        Variant3(BarePath),
-        Variant4(Flag),
-        Variant5(i64),
-        Variant6(String),
-        Variant7(Operator),
-        Variant8(Pipeline),
+        Variant1(::std::vec::Vec<SpannedToken<'input>>),
+        Variant2(Expression),
+        Variant3(::std::vec::Vec<Expression>),
+        Variant4(usize),
+        Variant5(Bare),
+        Variant6(i64),
+        Variant7(String),
+        Variant8(Operator),
+        Variant9(Pipeline),
+        Variant10(Spanned<Operator>),
     }
     const __ACTION: &'static [i8] = &[
         // State 0
-        0, 16, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 19, 0, 20, 0, 21, 0, 0, 22, 0, 0,
+        0, 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 21, 0, 22, 0, 23, 0, 0, 24, 0, 0,
         // State 1
-        24, 0, 0, 0, 0, 0, 25, 26, 27, 28, 29, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        27, 0, 0, 0, 0, 0, 28, 29, 30, 31, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 2
-        -10, 16, 17, 0, 37, 38, -10, -10, -10, -10, -10, 0, 18, 0, 19, 0, 20, 0, 21, 0, 0, 22, -44, 0,
+        -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, 0, -17, 0, -17, 0, -17, 0, -17, 0, 0, -17, -17, -17,
         // State 3
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -50, -50,
+        -15, 18, 19, 0, 40, 41, -15, -15, -15, -15, -15, 0, 20, 0, 21, 0, 22, 0, 23, 0, 0, 24, -52, 0,
         // State 4
-        -22, -22, -22, -22, -22, -22, -22, -22, -22, -22, -22, 0, -22, 0, -22, 0, -22, 0, -22, 0, 0, -22, -22, -22,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -58, -58,
         // State 5
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -49, -49,
+        -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, 0, -40, 0, -40, 0, -40, 0, 0, -40, -40, -40,
         // State 6
-        -9, 16, 17, 0, 37, 38, -9, -9, -9, -9, -9, 0, 18, 0, 19, 0, 20, 0, 21, 0, 0, 22, -48, -48,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -57, -57,
         // State 7
-        -30, -30, -30, -30, -30, -30, -30, -30, -30, -30, -30, 0, -30, 0, -30, 0, -30, 0, -30, 41, 0, -30, -30, -30,
+        -14, 18, 19, 0, 40, 41, -14, -14, -14, -14, -14, 0, 20, 0, 21, 0, 22, 0, 23, 0, 0, 24, -56, -56,
         // State 8
-        -21, -21, -21, -21, -21, -21, -21, -21, -21, -21, -21, 0, -21, 0, -21, 0, -21, 0, -21, 0, 0, -21, -21, -21,
+        -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, -33, 0, -33, 0, -33, 0, -33, 44, 0, -33, -33, -33,
         // State 9
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        -39, -39, -39, -39, -39, -39, -39, -39, -39, -39, -39, -39, -39, 0, -39, 0, -39, 0, -39, 0, 0, -39, -39, -39,
         // State 10
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 43, 0,
+        -27, -27, -27, -27, -27, -27, -27, -27, -27, -27, -27, 46, -27, 0, -27, 0, -27, 0, -27, 0, 0, -27, -27, -27,
         // State 11
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -45, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 12
-        -29, -29, -29, -29, -29, -29, -29, -29, -29, -29, -29, 0, -29, 0, -29, 0, -29, 0, -29, 0, 0, -29, -29, -29,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 0,
         // State 13
-        -31, -31, -31, -31, -31, -31, -31, -31, -31, -31, -31, 0, -31, 0, -31, 0, -31, 0, -31, 0, 0, -31, -31, -31,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -53, 0,
         // State 14
-        -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, 0, -32, 0, -32, 0, -32, 0, -32, 0, 0, -32, -32, -32,
+        -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, -32, 0, -32, 0, -32, 0, -32, 0, 0, -32, -32, -32,
         // State 15
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 44, 0, 0, 0,
+        -34, -34, -34, -34, -34, -34, -34, -34, -34, -34, -34, -34, -34, 0, -34, 0, -34, 0, -34, 0, 0, -34, -34, -34,
         // State 16
-        0, 16, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 19, 0, 20, 0, 21, 0, 0, 22, 0, 0,
+        -35, -35, -35, -35, -35, -35, -35, -35, -35, -35, -35, -35, -35, 0, -35, 0, -35, 0, -35, 0, 0, -35, -35, -35,
         // State 17
-        -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, 0, -11, 0, -11, 0, -11, 0, -11, 0, 0, -11, -11, -11,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 49, 0, 0, 0,
         // State 18
-        -52, -52, -52, -52, -52, -52, -52, -52, -52, -52, -52, 0, -52, 0, -52, 0, -52, 0, -52, 0, 0, -52, -52, -52,
+        0, 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 21, 0, 22, 0, 23, 0, 0, 24, 0, 0,
         // State 19
-        -28, -28, -28, -28, -28, -28, -28, -28, -28, -28, -28, 0, -28, 0, -28, 0, -28, 0, -28, -28, 0, -28, -28, -28,
+        -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, 0, -16, 0, -16, 0, -16, 0, -16, 0, 0, -16, -16, -16,
         // State 20
-        -51, -51, -51, -51, -51, -51, -51, -51, -51, -51, -51, 0, -51, 0, -51, 0, -51, 0, -51, 0, 0, -51, -51, -51,
+        -61, -61, -61, -61, -61, -61, -61, -61, -61, -61, -61, -61, -61, 0, -61, 0, -61, 0, -61, 0, 0, -61, -61, -61,
         // State 21
-        0, 16, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 19, 0, 20, 0, 21, 0, 0, 22, 0, 0,
+        -31, -31, -31, -31, -31, -31, -31, -31, -31, -31, -31, -31, -31, 0, -31, 0, -31, 0, -31, -31, 0, -31, -31, -31,
         // State 22
-        0, 16, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 19, 0, 20, 0, 21, 0, 0, 22, 0, 0,
+        -60, -60, -60, -60, -60, -60, -60, -60, -60, -60, -60, -60, -60, 0, -60, 0, -60, 0, -60, 0, 0, -60, -60, -60,
         // State 23
-        0, -37, -37, 0, 0, 0, 0, 0, 0, 0, 0, 0, -37, 0, -37, 0, -37, 0, -37, 0, 0, -37, 0, 0,
+        0, 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 21, 0, 22, 0, 23, 0, 0, 24, 0, 0,
         // State 24
-        0, -38, -38, 0, 0, 0, 0, 0, 0, 0, 0, 0, -38, 0, -38, 0, -38, 0, -38, 0, 0, -38, 0, 0,
+        0, -59, -59, 0, 0, 0, 0, 0, 0, 0, 0, 0, -59, 0, -59, 0, -59, 0, -59, 0, 0, -59, 0, 0,
         // State 25
-        0, -40, -40, 0, 0, 0, 0, 0, 0, 0, 0, 0, -40, 0, -40, 0, -40, 0, -40, 0, 0, -40, 0, 0,
+        0, 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 21, 0, 22, 0, 23, 0, 0, 24, 0, 0,
         // State 26
-        0, -36, -36, 0, 0, 0, 0, 0, 0, 0, 0, 0, -36, 0, -36, 0, -36, 0, -36, 0, 0, -36, 0, 0,
+        0, -45, -45, 0, 0, 0, 0, 0, 0, 0, 0, 0, -45, 0, -45, 0, -45, 0, -45, 0, 0, -45, 0, 0,
         // State 27
-        0, -39, -39, 0, 0, 0, 0, 0, 0, 0, 0, 0, -39, 0, -39, 0, -39, 0, -39, 0, 0, -39, 0, 0,
+        0, -46, -46, 0, 0, 0, 0, 0, 0, 0, 0, 0, -46, 0, -46, 0, -46, 0, -46, 0, 0, -46, 0, 0,
         // State 28
-        0, -41, -41, 0, 0, 0, 0, 0, 0, 0, 0, 0, -41, 0, -41, 0, -41, 0, -41, 0, 0, -41, 0, 0,
+        0, -48, -48, 0, 0, 0, 0, 0, 0, 0, 0, 0, -48, 0, -48, 0, -48, 0, -48, 0, 0, -48, 0, 0,
         // State 29
-        24, -19, -19, -19, -19, -19, 25, 26, 27, 28, 29, 0, -19, 0, -19, 0, -19, 0, -19, 0, 0, -19, -19, -19,
+        0, -44, -44, 0, 0, 0, 0, 0, 0, 0, 0, 0, -44, 0, -44, 0, -44, 0, -44, 0, 0, -44, 0, 0,
         // State 30
-        -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, 0, -10, 0, -10, 0, -10, 0, -10, 0, 0, -10, -10, -10,
+        0, -47, -47, 0, 0, 0, 0, 0, 0, 0, 0, 0, -47, 0, -47, 0, -47, 0, -47, 0, 0, -47, 0, 0,
         // State 31
-        0, 0, 0, -47, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -47, -47,
+        0, -49, -49, 0, 0, 0, 0, 0, 0, 0, 0, 0, -49, 0, -49, 0, -49, 0, -49, 0, 0, -49, 0, 0,
         // State 32
-        0, 16, 17, -46, 37, 38, 0, 0, 0, 0, 0, 0, 18, 0, 19, 0, 20, 0, 21, 0, 0, 22, -46, -46,
+        27, -25, -25, -25, -25, -25, 28, 29, 30, 31, 32, 0, -25, 0, -25, 0, -25, 0, -25, 0, 0, -25, -25, -25,
         // State 33
-        -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, 0, -9, 0, -9, 0, -9, 0, -9, 0, 0, -9, -9, -9,
+        -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, 0, -15, 0, -15, 0, -15, 0, -15, 0, 0, -15, -15, -15,
         // State 34
-        0, -20, -20, -20, -20, -20, 0, 0, 0, 0, 0, 0, -20, 0, -20, 0, -20, 0, -20, 0, 0, -20, -20, -20,
+        0, 0, 0, -55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -55, -55,
         // State 35
-        0, 0, 0, -17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -17, -17,
+        0, 18, 19, -54, 40, 41, 0, 0, 0, 0, 0, 0, 20, 0, 21, 0, 22, 0, 23, 0, 0, 24, -54, -54,
         // State 36
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        // State 37
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        // State 38
-        0, 16, 17, -46, 37, 38, 0, 0, 0, 0, 0, 0, 18, 0, 19, 0, 20, 0, 21, 0, 0, 22, -46, -46,
-        // State 39
-        0, 0, 0, -15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -15, -15,
-        // State 40
-        -53, -53, -53, -53, -53, -53, -53, -53, -53, -53, -53, 0, -53, 0, -53, 0, -53, 0, -53, 0, 0, -53, -53, -53,
-        // State 41
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 58, 0,
-        // State 42
-        0, 16, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 19, 0, 20, 0, 21, 0, 0, 22, 0, 0,
-        // State 43
-        -54, -54, -54, -54, -54, -54, -54, -54, -54, -54, -54, 0, -54, 0, -54, 0, -54, 0, -54, 0, 0, -54, -54, -54,
-        // State 44
-        -10, 16, 17, 60, 37, 38, -10, -10, -10, -10, -10, 0, 18, 0, 19, 0, 20, 0, 21, 0, 0, 22, 0, 0,
-        // State 45
-        0, 0, 0, 61, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        // State 46
-        0, 0, 0, 62, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        // State 47
-        -9, 16, 17, 0, 37, 38, -9, -9, -9, -9, -9, 0, 18, 0, 19, 0, 20, 0, 21, 0, 0, 22, 0, 0,
-        // State 48
-        -10, 16, 17, 0, 37, 38, -10, -10, -10, -10, -10, 0, 18, 0, 19, 0, 20, 0, 21, 0, 0, 22, 0, 63,
-        // State 49
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64,
-        // State 50
-        0, 0, 0, -12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -12, -12,
-        // State 51
-        0, 16, 17, -18, 37, 38, 0, 0, 0, 0, 0, 0, 18, 0, 19, 0, 20, 0, 21, 0, 0, 22, -18, -18,
-        // State 52
-        0, -19, -19, -19, -19, -19, 0, 0, 0, 0, 0, 0, -19, 0, -19, 0, -19, 0, -19, 0, 0, -19, -19, -19,
-        // State 53
-        0, -7, -7, -7, -7, -7, 0, 0, 0, 0, 0, 0, -7, 0, -7, 0, -7, 0, -7, 0, 0, -7, -7, -7,
-        // State 54
-        0, -26, -26, -26, -26, -26, 0, 0, 0, 0, 0, 0, -26, 0, -26, 0, -26, 0, -26, 0, 0, -26, -26, -26,
-        // State 55
-        0, -27, -27, -27, -27, -27, 0, 0, 0, 0, 0, 0, -27, 0, -27, 0, -27, 0, -27, 0, 0, -27, -27, -27,
-        // State 56
-        0, 16, 17, -16, 37, 38, 0, 0, 0, 0, 0, 0, 18, 0, 19, 0, 20, 0, 21, 0, 0, 22, -16, -16,
-        // State 57
-        0, 16, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 19, 0, 20, 0, 21, 0, 0, 22, 0, 0,
-        // State 58
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -4, 0,
-        // State 59
-        -24, -24, -24, -24, -24, -24, -24, -24, -24, -24, -24, 0, -24, 0, -24, 0, -24, 0, -24, 0, 0, -24, -24, -24,
-        // State 60
-        -25, -25, -25, -25, -25, -25, -25, -25, -25, -25, -25, 0, -25, 0, -25, 0, -25, 0, -25, 0, 0, -25, -25, -25,
-        // State 61
-        -23, -23, -23, -23, -23, -23, -23, -23, -23, -23, -23, 0, -23, 0, -23, 0, -23, 0, -23, 0, 0, -23, -23, -23,
-        // State 62
         -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, 0, -14, 0, -14, 0, -14, 0, -14, 0, 0, -14, -14, -14,
+        // State 37
+        0, -26, -26, -26, -26, -26, 0, 0, 0, 0, 0, 0, -26, 0, -26, 0, -26, 0, -26, 0, 0, -26, -26, -26,
+        // State 38
+        0, 0, 0, -23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -23, -23,
+        // State 39
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 40
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 41
+        0, 18, 19, -54, 40, 41, 0, 0, 0, 0, 0, 0, 20, 0, 21, 0, 22, 0, 23, 0, 0, 24, -54, -54,
+        // State 42
+        0, 0, 0, -21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -21, -21,
+        // State 43
+        -62, -62, -62, -62, -62, -62, -62, -62, -62, -62, -62, -62, -62, 0, -62, 0, -62, 0, -62, 0, 0, -62, -62, -62,
+        // State 44
+        -28, -28, -28, -28, -28, -28, -28, -28, -28, -28, -28, 63, -28, 0, -28, 0, -28, 0, -28, 0, 0, -28, -28, -28,
+        // State 45
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 46
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, 0,
+        // State 47
+        0, 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 21, 0, 22, 0, 23, 0, 0, 24, 0, 0,
+        // State 48
+        -63, -63, -63, -63, -63, -63, -63, -63, -63, -63, -63, -63, -63, 0, -63, 0, -63, 0, -63, 0, 0, -63, -63, -63,
+        // State 49
+        -15, 18, 19, 67, 40, 41, -15, -15, -15, -15, -15, 0, 20, 0, 21, 0, 22, 0, 23, 0, 0, 24, 0, 0,
+        // State 50
+        0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 51
+        0, 0, 0, 69, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 52
+        -14, 18, 19, 0, 40, 41, -14, -14, -14, -14, -14, 0, 20, 0, 21, 0, 22, 0, 23, 0, 0, 24, 0, 0,
+        // State 53
+        -15, 18, 19, 0, 40, 41, -15, -15, -15, -15, -15, 0, 20, 0, 21, 0, 22, 0, 23, 0, 0, 24, 0, 70,
+        // State 54
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 71,
+        // State 55
+        0, 0, 0, -18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -18, -18,
+        // State 56
+        0, 18, 19, -24, 40, 41, 0, 0, 0, 0, 0, 0, 20, 0, 21, 0, 22, 0, 23, 0, 0, 24, -24, -24,
+        // State 57
+        0, -25, -25, -25, -25, -25, 0, 0, 0, 0, 0, 0, -25, 0, -25, 0, -25, 0, -25, 0, 0, -25, -25, -25,
+        // State 58
+        0, -10, -10, -10, -10, -10, 0, 0, 0, 0, 0, 0, -10, 0, -10, 0, -10, 0, -10, 0, 0, -10, -10, -10,
+        // State 59
+        0, -29, -29, -29, -29, -29, 0, 0, 0, 0, 0, 0, -29, 0, -29, 0, -29, 0, -29, 0, 0, -29, -29, -29,
+        // State 60
+        0, -30, -30, -30, -30, -30, 0, 0, 0, 0, 0, 0, -30, 0, -30, 0, -30, 0, -30, 0, 0, -30, -30, -30,
+        // State 61
+        0, 18, 19, -22, 40, 41, 0, 0, 0, 0, 0, 0, 20, 0, 21, 0, 22, 0, 23, 0, 0, 24, -22, -22,
+        // State 62
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 73, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 63
-        -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, 0, -13, 0, -13, 0, -13, 0, -13, 0, 0, -13, -13, -13,
+        -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 0, -2, 0, -2, 0, -2, 0, 0, -2, -2, -2,
         // State 64
-        0, -8, -8, -8, -8, -8, 0, 0, 0, 0, 0, 0, -8, 0, -8, 0, -8, 0, -8, 0, 0, -8, -8, -8,
+        0, 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 21, 0, 22, 0, 23, 0, 0, 24, 0, 0,
         // State 65
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -5, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -7, 0,
+        // State 66
+        -42, -42, -42, -42, -42, -42, -42, -42, -42, -42, -42, -42, -42, 0, -42, 0, -42, 0, -42, 0, 0, -42, -42, -42,
+        // State 67
+        -43, -43, -43, -43, -43, -43, -43, -43, -43, -43, -43, -43, -43, 0, -43, 0, -43, 0, -43, 0, 0, -43, -43, -43,
+        // State 68
+        -41, -41, -41, -41, -41, -41, -41, -41, -41, -41, -41, -41, -41, 0, -41, 0, -41, 0, -41, 0, 0, -41, -41, -41,
+        // State 69
+        -20, -20, -20, -20, -20, -20, -20, -20, -20, -20, -20, -20, -20, 0, -20, 0, -20, 0, -20, 0, 0, -20, -20, -20,
+        // State 70
+        -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, 0, -19, 0, -19, 0, -19, 0, 0, -19, -19, -19,
+        // State 71
+        0, -11, -11, -11, -11, -11, 0, 0, 0, 0, 0, 0, -11, 0, -11, 0, -11, 0, -11, 0, 0, -11, -11, -11,
+        // State 72
+        -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, 0, -3, 0, -3, 0, -3, 0, 0, -3, -3, -3,
+        // State 73
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -8, 0,
     ];
     const __EOF_ACTION: &'static [i8] = &[
         // State 0
@@ -2530,47 +2866,47 @@ mod __parse__Pipeline {
         // State 1
         0,
         // State 2
-        -44,
+        -17,
         // State 3
-        -50,
+        -52,
         // State 4
-        -22,
+        -58,
         // State 5
-        -49,
+        -40,
         // State 6
-        -48,
+        -57,
         // State 7
-        -30,
-        // State 8
-        -21,
-        // State 9
         -56,
+        // State 8
+        -33,
+        // State 9
+        -39,
         // State 10
-        -42,
+        -27,
         // State 11
-        -45,
+        -65,
         // State 12
-        -29,
+        -50,
         // State 13
-        -31,
+        -53,
         // State 14
         -32,
         // State 15
-        0,
+        -34,
         // State 16
-        0,
+        -35,
         // State 17
-        -11,
+        0,
         // State 18
-        -52,
+        0,
         // State 19
-        -28,
+        -16,
         // State 20
-        -51,
+        -61,
         // State 21
-        0,
+        -31,
         // State 22
-        0,
+        -60,
         // State 23
         0,
         // State 24
@@ -2584,213 +2920,245 @@ mod __parse__Pipeline {
         // State 28
         0,
         // State 29
-        -19,
+        0,
         // State 30
-        -10,
+        0,
         // State 31
-        -47,
+        0,
         // State 32
-        -46,
+        -25,
         // State 33
-        -9,
-        // State 34
-        -20,
-        // State 35
-        -17,
-        // State 36
-        0,
-        // State 37
-        0,
-        // State 38
-        -46,
-        // State 39
         -15,
-        // State 40
-        -53,
-        // State 41
-        -43,
-        // State 42
-        0,
-        // State 43
+        // State 34
+        -55,
+        // State 35
         -54,
-        // State 44
+        // State 36
+        -14,
+        // State 37
+        -26,
+        // State 38
+        -23,
+        // State 39
         0,
+        // State 40
+        0,
+        // State 41
+        -54,
+        // State 42
+        -21,
+        // State 43
+        -62,
+        // State 44
+        -28,
         // State 45
         0,
         // State 46
-        0,
+        -51,
         // State 47
         0,
         // State 48
-        0,
+        -63,
         // State 49
         0,
         // State 50
-        -12,
-        // State 51
-        -18,
-        // State 52
-        -19,
-        // State 53
-        -7,
-        // State 54
-        -26,
-        // State 55
-        -27,
-        // State 56
-        -16,
-        // State 57
         0,
-        // State 58
-        -4,
-        // State 59
+        // State 51
+        0,
+        // State 52
+        0,
+        // State 53
+        0,
+        // State 54
+        0,
+        // State 55
+        -18,
+        // State 56
         -24,
-        // State 60
+        // State 57
         -25,
+        // State 58
+        -10,
+        // State 59
+        -29,
+        // State 60
+        -30,
         // State 61
-        -23,
+        -22,
         // State 62
-        -14,
+        0,
         // State 63
-        -13,
+        -2,
         // State 64
-        -8,
+        0,
         // State 65
-        -5,
+        -7,
+        // State 66
+        -42,
+        // State 67
+        -43,
+        // State 68
+        -41,
+        // State 69
+        -20,
+        // State 70
+        -19,
+        // State 71
+        -11,
+        // State 72
+        -3,
+        // State 73
+        -8,
     ];
     const __GOTO: &'static [i8] = &[
         // State 0
-        0, 0, 0, 0, 0, 2, 3, 4, 5, 6, 0, 7, 0, 8, 9, 0, 0, 10, 11, 0, 12, 13, 14, 15, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 4, 5, 6, 7, 0, 8, 0, 9, 10, 0, 11, 0, 12, 13, 0, 14, 0, 15, 16, 17, 0, 0,
         // State 1
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25, 0, 0, 0, 0, 26, 0, 0, 0, 0, 0,
         // State 2
-        0, 0, 0, 0, 0, 30, 31, 32, 5, 0, 33, 34, 35, 8, 9, 0, 0, 0, 0, 36, 0, 13, 14, 15, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 3
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 33, 3, 34, 35, 6, 0, 36, 37, 38, 9, 10, 0, 11, 0, 0, 0, 39, 0, 0, 15, 16, 17, 0, 0,
         // State 4
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 5
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 6
-        0, 0, 0, 0, 0, 30, 31, 32, 5, 0, 39, 34, 35, 8, 9, 0, 0, 0, 0, 40, 0, 13, 14, 15, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 7
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 33, 3, 34, 35, 6, 0, 42, 37, 38, 9, 10, 0, 11, 0, 0, 0, 43, 0, 0, 15, 16, 17, 0, 0,
         // State 8
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 9
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 10
-        0, 0, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 45, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 11
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 12
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 47, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 13
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 14
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 15
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 16
-        0, 0, 0, 0, 0, 2, 45, 46, 5, 47, 0, 48, 0, 8, 9, 0, 0, 0, 0, 0, 0, 13, 14, 15, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 17
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 18
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 50, 51, 6, 52, 0, 53, 0, 9, 10, 0, 11, 0, 0, 0, 0, 0, 0, 15, 16, 17, 0, 0,
         // State 19
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 20
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 21
-        0, 0, 0, 0, 0, 2, 49, 4, 5, 6, 0, 7, 0, 8, 9, 0, 0, 0, 0, 0, 50, 13, 14, 15, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 22
-        0, 0, 0, 0, 0, 51, 31, 0, 5, 0, 0, 34, 0, 8, 9, 0, 0, 0, 0, 0, 0, 13, 14, 15, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 23
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 54, 5, 6, 7, 0, 8, 0, 9, 10, 0, 11, 0, 0, 0, 0, 55, 0, 15, 16, 17, 0, 0,
         // State 24
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 25
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 3, 34, 0, 6, 0, 0, 37, 0, 9, 10, 0, 11, 0, 0, 0, 0, 0, 0, 15, 16, 17, 0, 0,
         // State 26
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 27
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 28
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 29
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 30
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 31
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 32
-        0, 0, 0, 0, 52, 53, 31, 0, 5, 0, 54, 34, 35, 8, 9, 0, 0, 0, 0, 0, 0, 13, 14, 15, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25, 0, 0, 0, 0, 26, 0, 0, 0, 0, 0,
         // State 33
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 34
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 35
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 57, 0, 0, 58, 3, 34, 0, 6, 0, 59, 37, 38, 9, 10, 0, 11, 0, 0, 0, 0, 0, 0, 15, 16, 17, 0, 0,
         // State 36
-        0, 0, 0, 0, 0, 0, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 37
-        0, 0, 0, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 38
-        0, 0, 0, 0, 57, 53, 31, 0, 5, 0, 54, 34, 35, 8, 9, 0, 0, 0, 0, 0, 0, 13, 14, 15, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 39
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 40
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 61, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 41
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 62, 0, 0, 58, 3, 34, 0, 6, 0, 59, 37, 38, 9, 10, 0, 11, 0, 0, 0, 0, 0, 0, 15, 16, 17, 0, 0,
         // State 42
-        0, 0, 0, 0, 0, 2, 3, 4, 5, 6, 0, 7, 0, 8, 9, 0, 0, 0, 59, 0, 12, 13, 14, 15, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 43
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 44
-        0, 0, 0, 0, 0, 30, 31, 32, 5, 0, 33, 34, 35, 8, 9, 0, 0, 0, 0, 36, 0, 13, 14, 15, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 45
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 46
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 47
-        0, 0, 0, 0, 0, 30, 31, 32, 5, 0, 39, 34, 35, 8, 9, 0, 0, 0, 0, 40, 0, 13, 14, 15, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 4, 5, 6, 7, 0, 8, 0, 9, 10, 0, 11, 0, 0, 66, 0, 14, 0, 15, 16, 17, 0, 0,
         // State 48
-        0, 0, 0, 0, 0, 30, 31, 32, 5, 0, 33, 34, 35, 8, 9, 0, 0, 0, 0, 36, 0, 13, 14, 15, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 49
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 33, 3, 34, 35, 6, 0, 36, 37, 38, 9, 10, 0, 11, 0, 0, 0, 39, 0, 0, 15, 16, 17, 0, 0,
         // State 50
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 51
-        0, 0, 0, 0, 0, 53, 31, 0, 5, 0, 65, 34, 35, 8, 9, 0, 0, 0, 0, 0, 0, 13, 14, 15, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 52
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 33, 3, 34, 35, 6, 0, 42, 37, 38, 9, 10, 0, 11, 0, 0, 0, 43, 0, 0, 15, 16, 17, 0, 0,
         // State 53
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 33, 3, 34, 35, 6, 0, 36, 37, 38, 9, 10, 0, 11, 0, 0, 0, 39, 0, 0, 15, 16, 17, 0, 0,
         // State 54
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 55
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 56
-        0, 0, 0, 0, 0, 53, 31, 0, 5, 0, 65, 34, 35, 8, 9, 0, 0, 0, 0, 0, 0, 13, 14, 15, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 58, 3, 34, 0, 6, 0, 72, 37, 38, 9, 10, 0, 11, 0, 0, 0, 0, 0, 0, 15, 16, 17, 0, 0,
         // State 57
-        0, 0, 0, 0, 0, 2, 3, 4, 5, 6, 0, 7, 0, 8, 9, 0, 0, 0, 66, 0, 12, 13, 14, 15, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 58
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 59
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 60
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 61
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 58, 3, 34, 0, 6, 0, 72, 37, 38, 9, 10, 0, 11, 0, 0, 0, 0, 0, 0, 15, 16, 17, 0, 0,
         // State 62
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 63
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         // State 64
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 4, 5, 6, 7, 0, 8, 0, 9, 10, 0, 11, 0, 0, 74, 0, 14, 0, 15, 16, 17, 0, 0,
         // State 65
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 66
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 67
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 68
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 69
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 70
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 71
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 72
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 73
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ];
     fn __expected_tokens(__state: usize) -> Vec<::std::string::String> {
         const __TERMINAL: &'static [&'static str] = &[
@@ -2878,7 +3246,7 @@ mod __parse__Pipeline {
 
         #[inline]
         fn goto(&self, state: i8, nt: usize) -> i8 {
-            __GOTO[(state as usize) * 26 + nt] - 1
+            __GOTO[(state as usize) * 33 + nt] - 1
         }
 
         fn token_to_symbol(&self, token_index: usize, token: Self::Token) -> Self::Symbol {
@@ -3081,13 +3449,13 @@ mod __parse__Pipeline {
             }
             1 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 0,
+                    states_to_pop: 2,
                     nonterminal_produced: 1,
                 }
             }
             2 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
+                    states_to_pop: 3,
                     nonterminal_produced: 1,
                 }
             }
@@ -3099,8 +3467,8 @@ mod __parse__Pipeline {
             }
             4 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 3,
-                    nonterminal_produced: 2,
+                    states_to_pop: 0,
+                    nonterminal_produced: 3,
                 }
             }
             5 => {
@@ -3111,13 +3479,13 @@ mod __parse__Pipeline {
             }
             6 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
+                    states_to_pop: 2,
                     nonterminal_produced: 4,
                 }
             }
             7 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 2,
+                    states_to_pop: 3,
                     nonterminal_produced: 4,
                 }
             }
@@ -3130,280 +3498,334 @@ mod __parse__Pipeline {
             9 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 5,
+                    nonterminal_produced: 6,
                 }
             }
             10 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
+                    states_to_pop: 2,
                     nonterminal_produced: 6,
                 }
             }
             11 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 3,
+                    states_to_pop: 0,
                     nonterminal_produced: 7,
                 }
             }
             12 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 3,
+                    states_to_pop: 0,
                     nonterminal_produced: 8,
                 }
             }
             13 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 3,
-                    nonterminal_produced: 8,
+                    states_to_pop: 1,
+                    nonterminal_produced: 9,
                 }
             }
             14 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 2,
+                    states_to_pop: 1,
                     nonterminal_produced: 9,
                 }
             }
             15 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 3,
-                    nonterminal_produced: 9,
+                    states_to_pop: 1,
+                    nonterminal_produced: 10,
                 }
             }
             16 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 2,
-                    nonterminal_produced: 9,
+                    states_to_pop: 1,
+                    nonterminal_produced: 11,
                 }
             }
             17 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 3,
-                    nonterminal_produced: 9,
+                    nonterminal_produced: 12,
                 }
             }
             18 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
-                    nonterminal_produced: 10,
+                    states_to_pop: 3,
+                    nonterminal_produced: 13,
                 }
             }
             19 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
-                    nonterminal_produced: 10,
+                    states_to_pop: 3,
+                    nonterminal_produced: 13,
                 }
             }
             20 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
-                    nonterminal_produced: 11,
+                    states_to_pop: 2,
+                    nonterminal_produced: 14,
                 }
             }
             21 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
-                    nonterminal_produced: 11,
+                    states_to_pop: 3,
+                    nonterminal_produced: 14,
                 }
             }
             22 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 3,
-                    nonterminal_produced: 11,
+                    states_to_pop: 2,
+                    nonterminal_produced: 14,
                 }
             }
             23 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 3,
-                    nonterminal_produced: 11,
+                    nonterminal_produced: 14,
                 }
             }
             24 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 3,
-                    nonterminal_produced: 11,
+                    states_to_pop: 1,
+                    nonterminal_produced: 15,
                 }
             }
             25 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 2,
-                    nonterminal_produced: 12,
+                    states_to_pop: 1,
+                    nonterminal_produced: 15,
                 }
             }
             26 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 2,
-                    nonterminal_produced: 12,
+                    states_to_pop: 1,
+                    nonterminal_produced: 16,
                 }
             }
             27 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
-                    nonterminal_produced: 13,
+                    states_to_pop: 2,
+                    nonterminal_produced: 16,
                 }
             }
             28 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
-                    nonterminal_produced: 14,
+                    states_to_pop: 2,
+                    nonterminal_produced: 17,
                 }
             }
             29 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
-                    nonterminal_produced: 14,
+                    states_to_pop: 2,
+                    nonterminal_produced: 17,
                 }
             }
             30 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 14,
+                    nonterminal_produced: 18,
                 }
             }
             31 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 14,
+                    nonterminal_produced: 19,
                 }
             }
             32 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 15,
+                    nonterminal_produced: 19,
                 }
             }
             33 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 15,
+                    nonterminal_produced: 19,
                 }
             }
             34 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 15,
+                    nonterminal_produced: 19,
                 }
             }
             35 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 16,
+                    nonterminal_produced: 20,
                 }
             }
             36 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 16,
+                    nonterminal_produced: 20,
                 }
             }
             37 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 16,
+                    nonterminal_produced: 20,
                 }
             }
             38 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 16,
+                    nonterminal_produced: 21,
                 }
             }
             39 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 16,
+                    nonterminal_produced: 21,
                 }
             }
             40 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
-                    nonterminal_produced: 16,
+                    states_to_pop: 3,
+                    nonterminal_produced: 21,
                 }
             }
             41 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
-                    nonterminal_produced: 17,
+                    states_to_pop: 3,
+                    nonterminal_produced: 21,
                 }
             }
             42 => {
                 __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 2,
-                    nonterminal_produced: 17,
+                    states_to_pop: 3,
+                    nonterminal_produced: 21,
                 }
             }
             43 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 18,
+                    nonterminal_produced: 22,
                 }
             }
             44 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 18,
+                    nonterminal_produced: 22,
                 }
             }
             45 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 19,
+                    nonterminal_produced: 22,
                 }
             }
             46 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 19,
+                    nonterminal_produced: 22,
                 }
             }
             47 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 20,
+                    nonterminal_produced: 22,
                 }
             }
             48 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 20,
+                    nonterminal_produced: 22,
                 }
             }
             49 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
-                    nonterminal_produced: 20,
+                    nonterminal_produced: 23,
                 }
             }
             50 => {
-                __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
-                    nonterminal_produced: 21,
-                }
-            }
-            51 => {
-                __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 1,
-                    nonterminal_produced: 21,
-                }
-            }
-            52 => {
-                __state_machine::SimulatedReduce::Reduce {
-                    states_to_pop: 2,
-                    nonterminal_produced: 22,
-                }
-            }
-            53 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 2,
                     nonterminal_produced: 23,
                 }
             }
-            54 => {
+            51 => {
                 __state_machine::SimulatedReduce::Reduce {
                     states_to_pop: 1,
                     nonterminal_produced: 24,
                 }
             }
-            55 => __state_machine::SimulatedReduce::Accept,
+            52 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 1,
+                    nonterminal_produced: 24,
+                }
+            }
+            53 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 1,
+                    nonterminal_produced: 25,
+                }
+            }
+            54 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 1,
+                    nonterminal_produced: 25,
+                }
+            }
+            55 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 1,
+                    nonterminal_produced: 26,
+                }
+            }
+            56 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 1,
+                    nonterminal_produced: 26,
+                }
+            }
+            57 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 1,
+                    nonterminal_produced: 26,
+                }
+            }
+            58 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 1,
+                    nonterminal_produced: 27,
+                }
+            }
+            59 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 1,
+                    nonterminal_produced: 28,
+                }
+            }
+            60 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 1,
+                    nonterminal_produced: 28,
+                }
+            }
+            61 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 2,
+                    nonterminal_produced: 29,
+                }
+            }
+            62 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 2,
+                    nonterminal_produced: 30,
+                }
+            }
+            63 => {
+                __state_machine::SimulatedReduce::Reduce {
+                    states_to_pop: 1,
+                    nonterminal_produced: 31,
+                }
+            }
+            64 => __state_machine::SimulatedReduce::Accept,
             _ => panic!("invalid reduction index {}", __reduce_index)
         }
     }
@@ -3616,8 +4038,35 @@ mod __parse__Pipeline {
                 __reduce54(__action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)
             }
             55 => {
+                __reduce55(__action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)
+            }
+            56 => {
+                __reduce56(__action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)
+            }
+            57 => {
+                __reduce57(__action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)
+            }
+            58 => {
+                __reduce58(__action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)
+            }
+            59 => {
+                __reduce59(__action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)
+            }
+            60 => {
+                __reduce60(__action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)
+            }
+            61 => {
+                __reduce61(__action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)
+            }
+            62 => {
+                __reduce62(__action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)
+            }
+            63 => {
+                __reduce63(__action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<(&())>)
+            }
+            64 => {
                 // __Pipeline = Pipeline => ActionFn(0);
-                let __sym0 = __pop_Variant8(__symbols);
+                let __sym0 = __pop_Variant9(__symbols);
                 let __start = __sym0.0.clone();
                 let __end = __sym0.2.clone();
                 let __nt = super::__action0::<>(__sym0);
@@ -3628,51 +4077,29 @@ mod __parse__Pipeline {
         let __states_len = __states.len();
         __states.truncate(__states_len - __pop_states);
         let __state = *__states.last().unwrap() as usize;
-        let __next_state = __GOTO[__state * 26 + __nonterminal] - 1;
+        let __next_state = __GOTO[__state * 33 + __nonterminal] - 1;
         __states.push(__next_state);
         None
     }
-    fn __pop_Variant3<
+    fn __pop_Variant5<
       'input,
     >(
         __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
-    ) -> (usize, BarePath, usize)
+    ) -> (usize, Bare, usize)
      {
         match __symbols.pop().unwrap() {
-            (__l, __Symbol::Variant3(__v), __r) => (__l, __v, __r),
+            (__l, __Symbol::Variant5(__v), __r) => (__l, __v, __r),
             _ => panic!("symbol type mismatch")
         }
     }
-    fn __pop_Variant1<
+    fn __pop_Variant2<
       'input,
     >(
         __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
     ) -> (usize, Expression, usize)
      {
         match __symbols.pop().unwrap() {
-            (__l, __Symbol::Variant1(__v), __r) => (__l, __v, __r),
-            _ => panic!("symbol type mismatch")
-        }
-    }
-    fn __pop_Variant4<
-      'input,
-    >(
-        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
-    ) -> (usize, Flag, usize)
-     {
-        match __symbols.pop().unwrap() {
-            (__l, __Symbol::Variant4(__v), __r) => (__l, __v, __r),
-            _ => panic!("symbol type mismatch")
-        }
-    }
-    fn __pop_Variant7<
-      'input,
-    >(
-        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
-    ) -> (usize, Operator, usize)
-     {
-        match __symbols.pop().unwrap() {
-            (__l, __Symbol::Variant7(__v), __r) => (__l, __v, __r),
+            (__l, __Symbol::Variant2(__v), __r) => (__l, __v, __r),
             _ => panic!("symbol type mismatch")
         }
     }
@@ -3680,13 +4107,35 @@ mod __parse__Pipeline {
       'input,
     >(
         __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
-    ) -> (usize, Pipeline, usize)
+    ) -> (usize, Operator, usize)
      {
         match __symbols.pop().unwrap() {
             (__l, __Symbol::Variant8(__v), __r) => (__l, __v, __r),
             _ => panic!("symbol type mismatch")
         }
     }
+    fn __pop_Variant9<
+      'input,
+    >(
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, Pipeline, usize)
+     {
+        match __symbols.pop().unwrap() {
+            (__l, __Symbol::Variant9(__v), __r) => (__l, __v, __r),
+            _ => panic!("symbol type mismatch")
+        }
+    }
+    fn __pop_Variant10<
+      'input,
+    >(
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, Spanned<Operator>, usize)
+     {
+        match __symbols.pop().unwrap() {
+            (__l, __Symbol::Variant10(__v), __r) => (__l, __v, __r),
+            _ => panic!("symbol type mismatch")
+        }
+    }
     fn __pop_Variant0<
       'input,
     >(
@@ -3698,36 +4147,58 @@ mod __parse__Pipeline {
             _ => panic!("symbol type mismatch")
         }
     }
-    fn __pop_Variant6<
+    fn __pop_Variant7<
       'input,
     >(
         __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
     ) -> (usize, String, usize)
      {
         match __symbols.pop().unwrap() {
-            (__l, __Symbol::Variant6(__v), __r) => (__l, __v, __r),
+            (__l, __Symbol::Variant7(__v), __r) => (__l, __v, __r),
             _ => panic!("symbol type mismatch")
         }
     }
-    fn __pop_Variant5<
+    fn __pop_Variant6<
       'input,
     >(
         __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
     ) -> (usize, i64, usize)
      {
         match __symbols.pop().unwrap() {
-            (__l, __Symbol::Variant5(__v), __r) => (__l, __v, __r),
+            (__l, __Symbol::Variant6(__v), __r) => (__l, __v, __r),
             _ => panic!("symbol type mismatch")
         }
     }
-    fn __pop_Variant2<
+    fn __pop_Variant4<
+      'input,
+    >(
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, usize, usize)
+     {
+        match __symbols.pop().unwrap() {
+            (__l, __Symbol::Variant4(__v), __r) => (__l, __v, __r),
+            _ => panic!("symbol type mismatch")
+        }
+    }
+    fn __pop_Variant3<
       'input,
     >(
         __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
     ) -> (usize, ::std::vec::Vec<Expression>, usize)
      {
         match __symbols.pop().unwrap() {
-            (__l, __Symbol::Variant2(__v), __r) => (__l, __v, __r),
+            (__l, __Symbol::Variant3(__v), __r) => (__l, __v, __r),
+            _ => panic!("symbol type mismatch")
+        }
+    }
+    fn __pop_Variant1<
+      'input,
+    >(
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, ::std::vec::Vec<SpannedToken<'input>>, usize)
+     {
+        match __symbols.pop().unwrap() {
+            (__l, __Symbol::Variant1(__v), __r) => (__l, __v, __r),
             _ => panic!("symbol type mismatch")
         }
     }
@@ -3741,13 +4212,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // ("|" <PipelineElement>) = "|", PipelineElement => ActionFn(52);
-        let __sym1 = __pop_Variant1(__symbols);
+        // ("???." <"member">) = "???.", "member" => ActionFn(53);
+        let __sym1 = __pop_Variant0(__symbols);
         let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym1.2.clone();
-        let __nt = super::__action52::<>(__sym0, __sym1);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
+        let __nt = super::__action53::<>(__sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant0(__nt), __end));
         (2, 0)
     }
     pub(crate) fn __reduce1<
@@ -3760,12 +4231,14 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // ("|" <PipelineElement>)* =  => ActionFn(50);
-        let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();
-        let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());
-        let __nt = super::__action50::<>(&__start, &__end);
-        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
-        (0, 1)
+        // ("???." <"member">)+ = "???.", "member" => ActionFn(64);
+        let __sym1 = __pop_Variant0(__symbols);
+        let __sym0 = __pop_Variant0(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym1.2.clone();
+        let __nt = super::__action64::<>(__sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
+        (2, 1)
     }
     pub(crate) fn __reduce2<
         'input,
@@ -3777,13 +4250,15 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // ("|" <PipelineElement>)* = ("|" <PipelineElement>)+ => ActionFn(51);
-        let __sym0 = __pop_Variant2(__symbols);
+        // ("???." <"member">)+ = ("???." <"member">)+, "???.", "member" => ActionFn(65);
+        let __sym2 = __pop_Variant0(__symbols);
+        let __sym1 = __pop_Variant0(__symbols);
+        let __sym0 = __pop_Variant1(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action51::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
-        (1, 1)
+        let __end = __sym2.2.clone();
+        let __nt = super::__action65::<>(__sym0, __sym1, __sym2);
+        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
+        (3, 1)
     }
     pub(crate) fn __reduce3<
         'input,
@@ -3795,12 +4270,12 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // ("|" <PipelineElement>)+ = "|", PipelineElement => ActionFn(55);
-        let __sym1 = __pop_Variant1(__symbols);
+        // ("|" <PipelineElement>) = "|", PipelineElement => ActionFn(60);
+        let __sym1 = __pop_Variant2(__symbols);
         let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym1.2.clone();
-        let __nt = super::__action55::<>(__sym0, __sym1);
+        let __nt = super::__action60::<>(__sym0, __sym1);
         __symbols.push((__start, __Symbol::Variant2(__nt), __end));
         (2, 2)
     }
@@ -3814,15 +4289,12 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // ("|" <PipelineElement>)+ = ("|" <PipelineElement>)+, "|", PipelineElement => ActionFn(56);
-        let __sym2 = __pop_Variant1(__symbols);
-        let __sym1 = __pop_Variant0(__symbols);
-        let __sym0 = __pop_Variant2(__symbols);
-        let __start = __sym0.0.clone();
-        let __end = __sym2.2.clone();
-        let __nt = super::__action56::<>(__sym0, __sym1, __sym2);
-        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
-        (3, 2)
+        // ("|" <PipelineElement>)* =  => ActionFn(58);
+        let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();
+        let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());
+        let __nt = super::__action58::<>(&__start, &__end);
+        __symbols.push((__start, __Symbol::Variant3(__nt), __end));
+        (0, 3)
     }
     pub(crate) fn __reduce5<
         'input,
@@ -3834,12 +4306,12 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // (<CallArgument>) = CallArgument => ActionFn(49);
-        let __sym0 = __pop_Variant1(__symbols);
+        // ("|" <PipelineElement>)* = ("|" <PipelineElement>)+ => ActionFn(59);
+        let __sym0 = __pop_Variant3(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action49::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
+        let __nt = super::__action59::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant3(__nt), __end));
         (1, 3)
     }
     pub(crate) fn __reduce6<
@@ -3852,13 +4324,14 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // (<CallArgument>)+ = CallArgument => ActionFn(59);
-        let __sym0 = __pop_Variant1(__symbols);
+        // ("|" <PipelineElement>)+ = "|", PipelineElement => ActionFn(66);
+        let __sym1 = __pop_Variant2(__symbols);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action59::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
-        (1, 4)
+        let __end = __sym1.2.clone();
+        let __nt = super::__action66::<>(__sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant3(__nt), __end));
+        (2, 4)
     }
     pub(crate) fn __reduce7<
         'input,
@@ -3870,14 +4343,15 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // (<CallArgument>)+ = (<CallArgument>)+, CallArgument => ActionFn(60);
-        let __sym1 = __pop_Variant1(__symbols);
-        let __sym0 = __pop_Variant2(__symbols);
+        // ("|" <PipelineElement>)+ = ("|" <PipelineElement>)+, "|", PipelineElement => ActionFn(67);
+        let __sym2 = __pop_Variant2(__symbols);
+        let __sym1 = __pop_Variant0(__symbols);
+        let __sym0 = __pop_Variant3(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym1.2.clone();
-        let __nt = super::__action60::<>(__sym0, __sym1);
-        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
-        (2, 4)
+        let __end = __sym2.2.clone();
+        let __nt = super::__action67::<>(__sym0, __sym1, __sym2);
+        __symbols.push((__start, __Symbol::Variant3(__nt), __end));
+        (3, 4)
     }
     pub(crate) fn __reduce8<
         'input,
@@ -3889,12 +4363,12 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // ArgumentExpression = Expression => ActionFn(21);
-        let __sym0 = __pop_Variant1(__symbols);
+        // (<CallArgument>) = CallArgument => ActionFn(56);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action21::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
+        let __nt = super::__action56::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
         (1, 5)
     }
     pub(crate) fn __reduce9<
@@ -3907,13 +4381,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // ArgumentExpression = Bare => ActionFn(22);
-        let __sym0 = __pop_Variant3(__symbols);
+        // (<CallArgument>)+ = CallArgument => ActionFn(70);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action22::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 5)
+        let __nt = super::__action70::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant3(__nt), __end));
+        (1, 6)
     }
     pub(crate) fn __reduce10<
         'input,
@@ -3925,13 +4399,14 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Bare = "bare" => ActionFn(30);
-        let __sym0 = __pop_Variant0(__symbols);
+        // (<CallArgument>)+ = (<CallArgument>)+, CallArgument => ActionFn(71);
+        let __sym1 = __pop_Variant2(__symbols);
+        let __sym0 = __pop_Variant3(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action30::<>(__sym0);
+        let __end = __sym1.2.clone();
+        let __nt = super::__action71::<>(__sym0, __sym1);
         __symbols.push((__start, __Symbol::Variant3(__nt), __end));
-        (1, 6)
+        (2, 6)
     }
     pub(crate) fn __reduce11<
         'input,
@@ -3943,15 +4418,12 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Binary = ArgumentExpression, Operator, ArgumentExpression => ActionFn(13);
-        let __sym2 = __pop_Variant1(__symbols);
-        let __sym1 = __pop_Variant7(__symbols);
-        let __sym0 = __pop_Variant1(__symbols);
-        let __start = __sym0.0.clone();
-        let __end = __sym2.2.clone();
-        let __nt = super::__action13::<>(__sym0, __sym1, __sym2);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (3, 7)
+        // @L =  => ActionFn(61);
+        let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();
+        let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());
+        let __nt = super::__action61::<>(&__start, &__end);
+        __symbols.push((__start, __Symbol::Variant4(__nt), __end));
+        (0, 7)
     }
     pub(crate) fn __reduce12<
         'input,
@@ -3963,15 +4435,12 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Block = "{", SingleExpression, "}" => ActionFn(14);
-        let __sym2 = __pop_Variant0(__symbols);
-        let __sym1 = __pop_Variant1(__symbols);
-        let __sym0 = __pop_Variant0(__symbols);
-        let __start = __sym0.0.clone();
-        let __end = __sym2.2.clone();
-        let __nt = super::__action14::<>(__sym0, __sym1, __sym2);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (3, 8)
+        // @R =  => ActionFn(57);
+        let __start = __symbols.last().map(|s| s.2.clone()).unwrap_or_default();
+        let __end = __lookahead_start.cloned().unwrap_or_else(|| __start.clone());
+        let __nt = super::__action57::<>(&__start, &__end);
+        __symbols.push((__start, __Symbol::Variant4(__nt), __end));
+        (0, 8)
     }
     pub(crate) fn __reduce13<
         'input,
@@ -3983,15 +4452,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Block = "{", Bare, "}" => ActionFn(15);
-        let __sym2 = __pop_Variant0(__symbols);
-        let __sym1 = __pop_Variant3(__symbols);
-        let __sym0 = __pop_Variant0(__symbols);
+        // ArgumentExpression = Expression => ActionFn(23);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym2.2.clone();
-        let __nt = super::__action15::<>(__sym0, __sym1, __sym2);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (3, 8)
+        let __end = __sym0.2.clone();
+        let __nt = super::__action23::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 9)
     }
     pub(crate) fn __reduce14<
         'input,
@@ -4003,14 +4470,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Call = Expression, SingleCallArgument => ActionFn(9);
-        let __sym1 = __pop_Variant1(__symbols);
-        let __sym0 = __pop_Variant1(__symbols);
+        // ArgumentExpression = BareExpression => ActionFn(24);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym1.2.clone();
-        let __nt = super::__action9::<>(__sym0, __sym1);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (2, 9)
+        let __end = __sym0.2.clone();
+        let __nt = super::__action24::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 9)
     }
     pub(crate) fn __reduce15<
         'input,
@@ -4022,15 +4488,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Call = Expression, CallArgument, (<CallArgument>)+ => ActionFn(10);
-        let __sym2 = __pop_Variant2(__symbols);
-        let __sym1 = __pop_Variant1(__symbols);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Bare = "bare" => ActionFn(34);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym2.2.clone();
-        let __nt = super::__action10::<>(__sym0, __sym1, __sym2);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (3, 9)
+        let __end = __sym0.2.clone();
+        let __nt = super::__action34::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant5(__nt), __end));
+        (1, 10)
     }
     pub(crate) fn __reduce16<
         'input,
@@ -4042,14 +4506,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Call = Bare, SingleCallArgument => ActionFn(11);
-        let __sym1 = __pop_Variant1(__symbols);
-        let __sym0 = __pop_Variant3(__symbols);
+        // BareExpression = Bare => ActionFn(95);
+        let __sym0 = __pop_Variant5(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym1.2.clone();
-        let __nt = super::__action11::<>(__sym0, __sym1);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (2, 9)
+        let __end = __sym0.2.clone();
+        let __nt = super::__action95::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 11)
     }
     pub(crate) fn __reduce17<
         'input,
@@ -4061,15 +4524,15 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Call = Bare, CallArgument, (<CallArgument>)+ => ActionFn(12);
+        // Binary = ArgumentExpression, SpannedOperator, ArgumentExpression => ActionFn(96);
         let __sym2 = __pop_Variant2(__symbols);
-        let __sym1 = __pop_Variant1(__symbols);
-        let __sym0 = __pop_Variant3(__symbols);
+        let __sym1 = __pop_Variant10(__symbols);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym2.2.clone();
-        let __nt = super::__action12::<>(__sym0, __sym1, __sym2);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (3, 9)
+        let __nt = super::__action96::<>(__sym0, __sym1, __sym2);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (3, 12)
     }
     pub(crate) fn __reduce18<
         'input,
@@ -4081,13 +4544,15 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // CallArgument = ArgumentExpression => ActionFn(23);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Block = "{", SingleExpression, "}" => ActionFn(97);
+        let __sym2 = __pop_Variant0(__symbols);
+        let __sym1 = __pop_Variant2(__symbols);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action23::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 10)
+        let __end = __sym2.2.clone();
+        let __nt = super::__action97::<>(__sym0, __sym1, __sym2);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (3, 13)
     }
     pub(crate) fn __reduce19<
         'input,
@@ -4099,13 +4564,15 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // CallArgument = Flag => ActionFn(24);
-        let __sym0 = __pop_Variant4(__symbols);
+        // Block = "{", BareExpression, "}" => ActionFn(98);
+        let __sym2 = __pop_Variant0(__symbols);
+        let __sym1 = __pop_Variant2(__symbols);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action24::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 10)
+        let __end = __sym2.2.clone();
+        let __nt = super::__action98::<>(__sym0, __sym1, __sym2);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (3, 13)
     }
     pub(crate) fn __reduce20<
         'input,
@@ -4117,13 +4584,14 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Expression = LeafExpression => ActionFn(16);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Call = Expression, SingleCallArgument => ActionFn(99);
+        let __sym1 = __pop_Variant2(__symbols);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action16::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 11)
+        let __end = __sym1.2.clone();
+        let __nt = super::__action99::<>(__sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (2, 14)
     }
     pub(crate) fn __reduce21<
         'input,
@@ -4135,13 +4603,15 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Expression = Block => ActionFn(17);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Call = Expression, CallArgument, (<CallArgument>)+ => ActionFn(100);
+        let __sym2 = __pop_Variant3(__symbols);
+        let __sym1 = __pop_Variant2(__symbols);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action17::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 11)
+        let __end = __sym2.2.clone();
+        let __nt = super::__action100::<>(__sym0, __sym1, __sym2);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (3, 14)
     }
     pub(crate) fn __reduce22<
         'input,
@@ -4153,15 +4623,14 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Expression = "(", Call, ")" => ActionFn(18);
-        let __sym2 = __pop_Variant0(__symbols);
-        let __sym1 = __pop_Variant1(__symbols);
-        let __sym0 = __pop_Variant0(__symbols);
+        // Call = BareExpression, SingleCallArgument => ActionFn(101);
+        let __sym1 = __pop_Variant2(__symbols);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym2.2.clone();
-        let __nt = super::__action18::<>(__sym0, __sym1, __sym2);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (3, 11)
+        let __end = __sym1.2.clone();
+        let __nt = super::__action101::<>(__sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (2, 14)
     }
     pub(crate) fn __reduce23<
         'input,
@@ -4173,15 +4642,15 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Expression = "(", Bare, ")" => ActionFn(19);
-        let __sym2 = __pop_Variant0(__symbols);
-        let __sym1 = __pop_Variant3(__symbols);
-        let __sym0 = __pop_Variant0(__symbols);
+        // Call = BareExpression, CallArgument, (<CallArgument>)+ => ActionFn(102);
+        let __sym2 = __pop_Variant3(__symbols);
+        let __sym1 = __pop_Variant2(__symbols);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym2.2.clone();
-        let __nt = super::__action19::<>(__sym0, __sym1, __sym2);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (3, 11)
+        let __nt = super::__action102::<>(__sym0, __sym1, __sym2);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (3, 14)
     }
     pub(crate) fn __reduce24<
         'input,
@@ -4193,15 +4662,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Expression = "(", Binary, ")" => ActionFn(20);
-        let __sym2 = __pop_Variant0(__symbols);
-        let __sym1 = __pop_Variant1(__symbols);
-        let __sym0 = __pop_Variant0(__symbols);
+        // CallArgument = ArgumentExpression => ActionFn(25);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym2.2.clone();
-        let __nt = super::__action20::<>(__sym0, __sym1, __sym2);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (3, 11)
+        let __end = __sym0.2.clone();
+        let __nt = super::__action25::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 15)
     }
     pub(crate) fn __reduce25<
         'input,
@@ -4213,14 +4680,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Flag = "-", Bare => ActionFn(44);
-        let __sym1 = __pop_Variant3(__symbols);
-        let __sym0 = __pop_Variant0(__symbols);
+        // CallArgument = Flag => ActionFn(26);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym1.2.clone();
-        let __nt = super::__action44::<>(__sym0, __sym1);
-        __symbols.push((__start, __Symbol::Variant4(__nt), __end));
-        (2, 12)
+        let __end = __sym0.2.clone();
+        let __nt = super::__action26::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 15)
     }
     pub(crate) fn __reduce26<
         'input,
@@ -4232,14 +4698,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Flag = "--", Bare => ActionFn(45);
-        let __sym1 = __pop_Variant3(__symbols);
-        let __sym0 = __pop_Variant0(__symbols);
+        // Expression = MemberHeadExpression => ActionFn(21);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym1.2.clone();
-        let __nt = super::__action45::<>(__sym0, __sym1);
-        __symbols.push((__start, __Symbol::Variant4(__nt), __end));
-        (2, 12)
+        let __end = __sym0.2.clone();
+        let __nt = super::__action21::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 16)
     }
     pub(crate) fn __reduce27<
         'input,
@@ -4251,13 +4716,14 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Int = "num" => ActionFn(40);
-        let __sym0 = __pop_Variant0(__symbols);
+        // Expression = MemberHeadExpression, ("???." <"member">)+ => ActionFn(103);
+        let __sym1 = __pop_Variant1(__symbols);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action40::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant5(__nt), __end));
-        (1, 13)
+        let __end = __sym1.2.clone();
+        let __nt = super::__action103::<>(__sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (2, 16)
     }
     pub(crate) fn __reduce28<
         'input,
@@ -4269,13 +4735,14 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // LeafExpression = String => ActionFn(5);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Flag = "-", Bare => ActionFn(104);
+        let __sym1 = __pop_Variant5(__symbols);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action5::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 14)
+        let __end = __sym1.2.clone();
+        let __nt = super::__action104::<>(__sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (2, 17)
     }
     pub(crate) fn __reduce29<
         'input,
@@ -4287,13 +4754,14 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // LeafExpression = Int => ActionFn(6);
-        let __sym0 = __pop_Variant5(__symbols);
+        // Flag = "--", Bare => ActionFn(105);
+        let __sym1 = __pop_Variant5(__symbols);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action6::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 14)
+        let __end = __sym1.2.clone();
+        let __nt = super::__action105::<>(__sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (2, 17)
     }
     pub(crate) fn __reduce30<
         'input,
@@ -4305,13 +4773,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // LeafExpression = UnitsNum => ActionFn(7);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Int = "num" => ActionFn(44);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action7::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 14)
+        let __nt = super::__action44::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant6(__nt), __end));
+        (1, 18)
     }
     pub(crate) fn __reduce31<
         'input,
@@ -4323,13 +4791,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // LeafExpression = Var => ActionFn(8);
-        let __sym0 = __pop_Variant1(__symbols);
+        // LeafExpression = String => ActionFn(5);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action8::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 14)
+        let __nt = super::__action5::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 19)
     }
     pub(crate) fn __reduce32<
         'input,
@@ -4341,13 +4809,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Member = "member" => ActionFn(31);
-        let __sym0 = __pop_Variant0(__symbols);
+        // LeafExpression = Int => ActionFn(106);
+        let __sym0 = __pop_Variant6(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action31::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant6(__nt), __end));
-        (1, 15)
+        let __nt = super::__action106::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 19)
     }
     pub(crate) fn __reduce33<
         'input,
@@ -4359,13 +4827,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Member = "dqmember" => ActionFn(32);
-        let __sym0 = __pop_Variant0(__symbols);
+        // LeafExpression = UnitsNum => ActionFn(7);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action32::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant6(__nt), __end));
-        (1, 15)
+        let __nt = super::__action7::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 19)
     }
     pub(crate) fn __reduce34<
         'input,
@@ -4377,13 +4845,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Member = "sqmember" => ActionFn(33);
-        let __sym0 = __pop_Variant0(__symbols);
+        // LeafExpression = Var => ActionFn(8);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action33::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant6(__nt), __end));
-        (1, 15)
+        let __nt = super::__action8::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 19)
     }
     pub(crate) fn __reduce35<
         'input,
@@ -4395,13 +4863,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Operator = "==" => ActionFn(34);
+        // Member = "member" => ActionFn(35);
         let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action34::<>(__sym0);
+        let __nt = super::__action35::<>(__sym0);
         __symbols.push((__start, __Symbol::Variant7(__nt), __end));
-        (1, 16)
+        (1, 20)
     }
     pub(crate) fn __reduce36<
         'input,
@@ -4413,13 +4881,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Operator = "!=" => ActionFn(35);
+        // Member = "dqmember" => ActionFn(36);
         let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action35::<>(__sym0);
+        let __nt = super::__action36::<>(__sym0);
         __symbols.push((__start, __Symbol::Variant7(__nt), __end));
-        (1, 16)
+        (1, 20)
     }
     pub(crate) fn __reduce37<
         'input,
@@ -4431,13 +4899,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Operator = "<" => ActionFn(36);
+        // Member = "sqmember" => ActionFn(37);
         let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action36::<>(__sym0);
+        let __nt = super::__action37::<>(__sym0);
         __symbols.push((__start, __Symbol::Variant7(__nt), __end));
-        (1, 16)
+        (1, 20)
     }
     pub(crate) fn __reduce38<
         'input,
@@ -4449,13 +4917,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Operator = ">" => ActionFn(37);
-        let __sym0 = __pop_Variant0(__symbols);
+        // MemberHeadExpression = LeafExpression => ActionFn(16);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action37::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant7(__nt), __end));
-        (1, 16)
+        let __nt = super::__action16::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 21)
     }
     pub(crate) fn __reduce39<
         'input,
@@ -4467,13 +4935,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Operator = "<=" => ActionFn(38);
-        let __sym0 = __pop_Variant0(__symbols);
+        // MemberHeadExpression = Block => ActionFn(17);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action38::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant7(__nt), __end));
-        (1, 16)
+        let __nt = super::__action17::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 21)
     }
     pub(crate) fn __reduce40<
         'input,
@@ -4485,13 +4953,15 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Operator = ">=" => ActionFn(39);
+        // MemberHeadExpression = "(", Call, ")" => ActionFn(107);
+        let __sym2 = __pop_Variant0(__symbols);
+        let __sym1 = __pop_Variant2(__symbols);
         let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action39::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant7(__nt), __end));
-        (1, 16)
+        let __end = __sym2.2.clone();
+        let __nt = super::__action107::<>(__sym0, __sym1, __sym2);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (3, 21)
     }
     pub(crate) fn __reduce41<
         'input,
@@ -4503,13 +4973,15 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Pipeline = PipelineElement => ActionFn(57);
-        let __sym0 = __pop_Variant1(__symbols);
+        // MemberHeadExpression = "(", BareExpression, ")" => ActionFn(108);
+        let __sym2 = __pop_Variant0(__symbols);
+        let __sym1 = __pop_Variant2(__symbols);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action57::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant8(__nt), __end));
-        (1, 17)
+        let __end = __sym2.2.clone();
+        let __nt = super::__action108::<>(__sym0, __sym1, __sym2);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (3, 21)
     }
     pub(crate) fn __reduce42<
         'input,
@@ -4521,14 +4993,15 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Pipeline = PipelineElement, ("|" <PipelineElement>)+ => ActionFn(58);
+        // MemberHeadExpression = "(", Binary, ")" => ActionFn(109);
+        let __sym2 = __pop_Variant0(__symbols);
         let __sym1 = __pop_Variant2(__symbols);
-        let __sym0 = __pop_Variant1(__symbols);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym1.2.clone();
-        let __nt = super::__action58::<>(__sym0, __sym1);
-        __symbols.push((__start, __Symbol::Variant8(__nt), __end));
-        (2, 17)
+        let __end = __sym2.2.clone();
+        let __nt = super::__action109::<>(__sym0, __sym1, __sym2);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (3, 21)
     }
     pub(crate) fn __reduce43<
         'input,
@@ -4540,13 +5013,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // PipelineElement = Bare => ActionFn(3);
-        let __sym0 = __pop_Variant3(__symbols);
+        // Operator = "==" => ActionFn(38);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action3::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 18)
+        let __nt = super::__action38::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant8(__nt), __end));
+        (1, 22)
     }
     pub(crate) fn __reduce44<
         'input,
@@ -4558,13 +5031,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // PipelineElement = SingleExpression => ActionFn(4);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Operator = "!=" => ActionFn(39);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action4::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 18)
+        let __nt = super::__action39::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant8(__nt), __end));
+        (1, 22)
     }
     pub(crate) fn __reduce45<
         'input,
@@ -4576,13 +5049,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // SingleCallArgument = CallArgument => ActionFn(25);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Operator = "<" => ActionFn(40);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action25::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 19)
+        let __nt = super::__action40::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant8(__nt), __end));
+        (1, 22)
     }
     pub(crate) fn __reduce46<
         'input,
@@ -4594,13 +5067,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // SingleCallArgument = Binary => ActionFn(26);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Operator = ">" => ActionFn(41);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action26::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 19)
+        let __nt = super::__action41::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant8(__nt), __end));
+        (1, 22)
     }
     pub(crate) fn __reduce47<
         'input,
@@ -4612,13 +5085,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // SingleExpression = Expression => ActionFn(27);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Operator = "<=" => ActionFn(42);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action27::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 20)
+        let __nt = super::__action42::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant8(__nt), __end));
+        (1, 22)
     }
     pub(crate) fn __reduce48<
         'input,
@@ -4630,13 +5103,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // SingleExpression = Call => ActionFn(28);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Operator = ">=" => ActionFn(43);
+        let __sym0 = __pop_Variant0(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action28::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 20)
+        let __nt = super::__action43::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant8(__nt), __end));
+        (1, 22)
     }
     pub(crate) fn __reduce49<
         'input,
@@ -4648,13 +5121,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // SingleExpression = Binary => ActionFn(29);
-        let __sym0 = __pop_Variant1(__symbols);
+        // Pipeline = PipelineElement => ActionFn(110);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action29::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 20)
+        let __nt = super::__action110::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant9(__nt), __end));
+        (1, 23)
     }
     pub(crate) fn __reduce50<
         'input,
@@ -4666,13 +5139,14 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // String = "sqstring" => ActionFn(42);
-        let __sym0 = __pop_Variant0(__symbols);
+        // Pipeline = PipelineElement, ("|" <PipelineElement>)+ => ActionFn(111);
+        let __sym1 = __pop_Variant3(__symbols);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym0.2.clone();
-        let __nt = super::__action42::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 21)
+        let __end = __sym1.2.clone();
+        let __nt = super::__action111::<>(__sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant9(__nt), __end));
+        (2, 23)
     }
     pub(crate) fn __reduce51<
         'input,
@@ -4684,13 +5158,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // String = "dqstring" => ActionFn(43);
-        let __sym0 = __pop_Variant0(__symbols);
+        // PipelineElement = BareExpression => ActionFn(112);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
-        let __nt = super::__action43::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 21)
+        let __nt = super::__action112::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 24)
     }
     pub(crate) fn __reduce52<
         'input,
@@ -4702,14 +5176,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // UnitsNum = Int, "unit" => ActionFn(41);
-        let __sym1 = __pop_Variant0(__symbols);
-        let __sym0 = __pop_Variant5(__symbols);
+        // PipelineElement = SingleExpression => ActionFn(4);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym1.2.clone();
-        let __nt = super::__action41::<>(__sym0, __sym1);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (2, 22)
+        let __end = __sym0.2.clone();
+        let __nt = super::__action4::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 24)
     }
     pub(crate) fn __reduce53<
         'input,
@@ -4721,14 +5194,13 @@ mod __parse__Pipeline {
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
     {
-        // Var = "$", "variable" => ActionFn(46);
-        let __sym1 = __pop_Variant0(__symbols);
-        let __sym0 = __pop_Variant0(__symbols);
+        // SingleCallArgument = CallArgument => ActionFn(27);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
-        let __end = __sym1.2.clone();
-        let __nt = super::__action46::<>(__sym0, __sym1);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (2, 23)
+        let __end = __sym0.2.clone();
+        let __nt = super::__action27::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 25)
     }
     pub(crate) fn __reduce54<
         'input,
@@ -4739,14 +5211,178 @@ mod __parse__Pipeline {
         __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
         _: ::std::marker::PhantomData<(&'input ())>,
     ) -> (usize, usize)
+    {
+        // SingleCallArgument = Binary => ActionFn(28);
+        let __sym0 = __pop_Variant2(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action28::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 25)
+    }
+    pub(crate) fn __reduce55<
+        'input,
+    >(
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // SingleExpression = Expression => ActionFn(29);
+        let __sym0 = __pop_Variant2(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action29::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 26)
+    }
+    pub(crate) fn __reduce56<
+        'input,
+    >(
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // SingleExpression = Call => ActionFn(30);
+        let __sym0 = __pop_Variant2(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action30::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 26)
+    }
+    pub(crate) fn __reduce57<
+        'input,
+    >(
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // SingleExpression = Binary => ActionFn(31);
+        let __sym0 = __pop_Variant2(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action31::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 26)
+    }
+    pub(crate) fn __reduce58<
+        'input,
+    >(
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // SpannedOperator = Operator => ActionFn(113);
+        let __sym0 = __pop_Variant8(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action113::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant10(__nt), __end));
+        (1, 27)
+    }
+    pub(crate) fn __reduce59<
+        'input,
+    >(
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // String = "sqstring" => ActionFn(114);
+        let __sym0 = __pop_Variant0(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action114::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 28)
+    }
+    pub(crate) fn __reduce60<
+        'input,
+    >(
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // String = "dqstring" => ActionFn(115);
+        let __sym0 = __pop_Variant0(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action115::<>(__sym0);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 28)
+    }
+    pub(crate) fn __reduce61<
+        'input,
+    >(
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // UnitsNum = Int, "unit" => ActionFn(116);
+        let __sym1 = __pop_Variant0(__symbols);
+        let __sym0 = __pop_Variant6(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym1.2.clone();
+        let __nt = super::__action116::<>(__sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (2, 29)
+    }
+    pub(crate) fn __reduce62<
+        'input,
+    >(
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
+    {
+        // Var = "$", "variable" => ActionFn(117);
+        let __sym1 = __pop_Variant0(__symbols);
+        let __sym0 = __pop_Variant0(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym1.2.clone();
+        let __nt = super::__action117::<>(__sym0, __sym1);
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (2, 30)
+    }
+    pub(crate) fn __reduce63<
+        'input,
+    >(
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<(&'input ())>,
+    ) -> (usize, usize)
     {
         // __Call = Call => ActionFn(1);
-        let __sym0 = __pop_Variant1(__symbols);
+        let __sym0 = __pop_Variant2(__symbols);
         let __start = __sym0.0.clone();
         let __end = __sym0.2.clone();
         let __nt = super::__action1::<>(__sym0);
-        __symbols.push((__start, __Symbol::Variant1(__nt), __end));
-        (1, 24)
+        __symbols.push((__start, __Symbol::Variant2(__nt), __end));
+        (1, 31)
     }
 }
 pub use self::__parse__Pipeline::PipelineParser;
@@ -4772,20 +5408,24 @@ fn __action1<
 fn __action2<
     'input,
 >(
+    (_, l, _): (usize, usize, usize),
     (_, first, _): (usize, Expression, usize),
     (_, rest, _): (usize, ::std::vec::Vec<Expression>, usize),
+    (_, r, _): (usize, usize, usize),
 ) -> Pipeline
 {
-    Pipeline::from_parts(first, rest)
+    Pipeline::from_parts(first, rest, l, r)
 }
 
 fn __action3<
     'input,
 >(
-    (_, __0, _): (usize, BarePath, usize),
+    (_, l, _): (usize, usize, usize),
+    (_, bare, _): (usize, Expression, usize),
+    (_, r, _): (usize, usize, usize),
 ) -> Expression
 {
-    Expression::call(Expression::bare(__0), vec![])
+    ExpressionBuilder::spanned_call((bare, vec![]), l, r)
 }
 
 fn __action4<
@@ -4803,16 +5443,18 @@ fn __action5<
     (_, __0, _): (usize, Expression, usize),
 ) -> Expression
 {
-    __0
+    (__0)
 }
 
 fn __action6<
     'input,
 >(
-    (_, __0, _): (usize, i64, usize),
+    (_, l, _): (usize, usize, usize),
+    (_, int, _): (usize, i64, usize),
+    (_, r, _): (usize, usize, usize),
 ) -> Expression
 {
-    Expression::leaf(Leaf::Int(__0))
+    ExpressionBuilder::spanned_int(int, l, r)
 }
 
 fn __action7<
@@ -4821,7 +5463,7 @@ fn __action7<
     (_, __0, _): (usize, Expression, usize),
 ) -> Expression
 {
-    __0
+    (__0)
 }
 
 fn __action8<
@@ -4830,82 +5472,99 @@ fn __action8<
     (_, __0, _): (usize, Expression, usize),
 ) -> Expression
 {
-    __0
+    (__0)
 }
 
 fn __action9<
     'input,
 >(
+    (_, l, _): (usize, usize, usize),
     (_, expr, _): (usize, Expression, usize),
     (_, rest, _): (usize, Expression, usize),
+    (_, r, _): (usize, usize, usize),
 ) -> Expression
 {
-    Expression::call(expr, vec![rest])
+    ExpressionBuilder::spanned_call((expr, vec![rest]), l, r)
 }
 
 fn __action10<
     'input,
 >(
+    (_, l, _): (usize, usize, usize),
     (_, expr, _): (usize, Expression, usize),
     (_, first, _): (usize, Expression, usize),
     (_, rest, _): (usize, ::std::vec::Vec<Expression>, usize),
+    (_, r, _): (usize, usize, usize),
 ) -> Expression
 {
-    Expression::call(expr, { let mut rest = rest; let mut v = vec![first]; v.append(&mut rest); v })
+    ExpressionBuilder::spanned_call((expr, { let mut rest = rest; let mut v = vec![first]; v.append(&mut rest); v }), l, r)
 }
 
 fn __action11<
     'input,
 >(
-    (_, expr, _): (usize, BarePath, usize),
+    (_, l, _): (usize, usize, usize),
+    (_, expr, _): (usize, Expression, usize),
     (_, rest, _): (usize, Expression, usize),
+    (_, r, _): (usize, usize, usize),
 ) -> Expression
 {
-    Expression::call(Expression::bare(expr), vec![rest])
+    ExpressionBuilder::spanned_call((expr, vec![rest]), l, r)
 }
 
 fn __action12<
     'input,
 >(
-    (_, expr, _): (usize, BarePath, usize),
+    (_, l, _): (usize, usize, usize),
+    (_, expr, _): (usize, Expression, usize),
     (_, first, _): (usize, Expression, usize),
     (_, rest, _): (usize, ::std::vec::Vec<Expression>, usize),
+    (_, r, _): (usize, usize, usize),
 ) -> Expression
 {
-    Expression::call(Expression::bare(expr), { let mut v = vec![first]; let mut rest = rest; v.append(&mut rest); v })
+    ExpressionBuilder::spanned_call((expr, { let mut v = vec![first]; let mut rest = rest; v.append(&mut rest); v }), l, r)
 }
 
 fn __action13<
     'input,
 >(
+    (_, l, _): (usize, usize, usize),
     (_, left, _): (usize, Expression, usize),
-    (_, op, _): (usize, Operator, usize),
+    (_, op, _): (usize, Spanned<Operator>, usize),
     (_, right, _): (usize, Expression, usize),
+    (_, r, _): (usize, usize, usize),
 ) -> Expression
 {
-    Expression::binary(left, op, right)
+    ExpressionBuilder::spanned_binary((left, op, right), l, r)
 }
 
 fn __action14<
     'input,
 >(
+    (_, l, _): (usize, usize, usize),
     (_, _, _): (usize, SpannedToken<'input>, usize),
-    (_, __0, _): (usize, Expression, usize),
+    (_, expr, _): (usize, Expression, usize),
     (_, _, _): (usize, SpannedToken<'input>, usize),
+    (_, r, _): (usize, usize, usize),
 ) -> Expression
 {
-    Expression::block(__0)
+    ExpressionBuilder::spanned_block(expr, l, r)
 }
 
 fn __action15<
     'input,
 >(
+    (_, l, _): (usize, usize, usize),
     (_, _, _): (usize, SpannedToken<'input>, usize),
-    (_, __0, _): (usize, BarePath, usize),
+    (_, bare, _): (usize, Expression, usize),
     (_, _, _): (usize, SpannedToken<'input>, usize),
+    (_, r, _): (usize, usize, usize),
 ) -> Expression
 {
-    Expression::block(Expression::call(Expression::bare(__0), vec![]))
+    {
+        let call = ExpressionBuilder::spanned_call(bare.clone(), bare.span.start, bare.span.end);
+        ExpressionBuilder::spanned_block(call, l, r)
+    }
 }
 
 fn __action16<
@@ -4929,34 +5588,40 @@ fn __action17<
 fn __action18<
     'input,
 >(
+    (_, l, _): (usize, usize, usize),
     (_, _, _): (usize, SpannedToken<'input>, usize),
-    (_, __0, _): (usize, Expression, usize),
+    (_, expr, _): (usize, Expression, usize),
     (_, _, _): (usize, SpannedToken<'input>, usize),
+    (_, r, _): (usize, usize, usize),
 ) -> Expression
 {
-    __0
+    ExpressionBuilder::spanned_call(expr, l, r)
 }
 
 fn __action19<
     'input,
 >(
+    (_, l, _): (usize, usize, usize),
     (_, _, _): (usize, SpannedToken<'input>, usize),
-    (_, __0, _): (usize, BarePath, usize),
+    (_, expr, _): (usize, Expression, usize),
     (_, _, _): (usize, SpannedToken<'input>, usize),
+    (_, r, _): (usize, usize, usize),
 ) -> Expression
 {
-    Expression::call(Expression::bare(__0), vec![])
+    ExpressionBuilder::spanned_call((expr, vec![]), l, r)
 }
 
 fn __action20<
     'input,
 >(
+    (_, l, _): (usize, usize, usize),
     (_, _, _): (usize, SpannedToken<'input>, usize),
-    (_, __0, _): (usize, Expression, usize),
+    (_, expr, _): (usize, Expression, usize),
     (_, _, _): (usize, SpannedToken<'input>, usize),
+    (_, r, _): (usize, usize, usize),
 ) -> Expression
 {
-    __0
+    ExpressionBuilder::spanned_parens(expr, l, r)
 }
 
 fn __action21<
@@ -4965,16 +5630,19 @@ fn __action21<
     (_, __0, _): (usize, Expression, usize),
 ) -> Expression
 {
-    (__0)
+    __0
 }
 
 fn __action22<
     'input,
 >(
-    (_, __0, _): (usize, BarePath, usize),
+    (_, l, _): (usize, usize, usize),
+    (_, expr, _): (usize, Expression, usize),
+    (_, rest, _): (usize, ::std::vec::Vec<SpannedToken<'input>>, usize),
+    (_, r, _): (usize, usize, usize),
 ) -> Expression
 {
-    Expression::bare(__0)
+    ExpressionBuilder::spanned_path((expr, rest.iter().map(|i| i.to_spanned_string()).collect()), l, r)
 }
 
 fn __action23<
@@ -4983,16 +5651,16 @@ fn __action23<
     (_, __0, _): (usize, Expression, usize),
 ) -> Expression
 {
-    __0
+    (__0)
 }
 
 fn __action24<
     'input,
 >(
-    (_, __0, _): (usize, Flag, usize),
+    (_, __0, _): (usize, Expression, usize),
 ) -> Expression
 {
-    Expression::flag(__0)
+    (__0)
 }
 
 fn __action25<
@@ -5043,73 +5711,77 @@ fn __action29<
 fn __action30<
     'input,
 >(
-    (_, head, _): (usize, SpannedToken<'input>, usize),
-) -> BarePath
+    (_, __0, _): (usize, Expression, usize),
+) -> Expression
 {
-    BarePath::from_token(head)
+    (__0)
 }
 
 fn __action31<
     'input,
 >(
-    (_, __0, _): (usize, SpannedToken<'input>, usize),
-) -> String
+    (_, __0, _): (usize, Expression, usize),
+) -> Expression
 {
-    __0.to_string()
+    (__0)
 }
 
 fn __action32<
     'input,
 >(
-    (_, __0, _): (usize, SpannedToken<'input>, usize),
-) -> String
+    (_, l, _): (usize, usize, usize),
+    (_, bare, _): (usize, Bare, usize),
+    (_, r, _): (usize, usize, usize),
+) -> Expression
 {
-    __0.to_string()
+    ExpressionBuilder::spanned_bare(bare, l, r)
 }
 
 fn __action33<
     'input,
 >(
-    (_, __0, _): (usize, SpannedToken<'input>, usize),
-) -> String
+    (_, l, _): (usize, usize, usize),
+    (_, op, _): (usize, Operator, usize),
+    (_, r, _): (usize, usize, usize),
+) -> Spanned<Operator>
 {
-    __0.to_string()
+    Spanned::from_item(op, Span::from((l, r)))
 }
 
 fn __action34<
     'input,
 >(
-    (_, __0, _): (usize, SpannedToken<'input>, usize),
-) -> Operator
+    (_, head, _): (usize, SpannedToken<'input>, usize),
+) -> Bare
 {
-    Operator::Equal
+    Bare::from_string(head.as_slice())
 }
 
 fn __action35<
     'input,
 >(
     (_, __0, _): (usize, SpannedToken<'input>, usize),
-) -> Operator
+) -> String
 {
-    Operator::NotEqual
+    __0.to_string()
 }
 
 fn __action36<
     'input,
 >(
     (_, __0, _): (usize, SpannedToken<'input>, usize),
-) -> Operator
+) -> String
 {
-    Operator::LessThan
+    __0.to_string()
 }
 
 fn __action37<
     'input,
 >(
     (_, __0, _): (usize, SpannedToken<'input>, usize),
-) -> Operator
+) -> String
 {
-    Operator::GreaterThan
+    __0.to_string()
 }
 
 fn __action38<
@@ -5118,7 +5790,7 @@ fn __action38<
     (_, __0, _): (usize, SpannedToken<'input>, usize),
 ) -> Operator
 {
-    Operator::LessThanOrEqual
+    Operator::Equal
 }
 
 fn __action39<
@@ -5127,78 +5799,155 @@ fn __action39<
     (_, __0, _): (usize, SpannedToken<'input>, usize),
 ) -> Operator
 {
-    Operator::GreaterThanOrEqual
+    Operator::NotEqual
 }
 
 fn __action40<
     'input,
 >(
     (_, __0, _): (usize, SpannedToken<'input>, usize),
-) -> i64
+) -> Operator
 {
-    i64::from_str(__0.as_slice()).unwrap()
+    Operator::LessThan
 }
 
 fn __action41<
     'input,
 >(
-    (_, num, _): (usize, i64, usize),
-    (_, unit, _): (usize, SpannedToken<'input>, usize),
-) -> Expression
+    (_, __0, _): (usize, SpannedToken<'input>, usize),
+) -> Operator
 {
-    Expression::leaf(Leaf::Unit(num, Unit::from_str(unit.as_slice()).unwrap()))
+    Operator::GreaterThan
 }
 
 fn __action42<
     'input,
 >(
     (_, __0, _): (usize, SpannedToken<'input>, usize),
-) -> Expression
+) -> Operator
 {
-    __0.as_slice()[1..(__0.as_slice().len() - 1)].to_string().into()
+    Operator::LessThanOrEqual
 }
 
 fn __action43<
     'input,
 >(
     (_, __0, _): (usize, SpannedToken<'input>, usize),
-) -> Expression
+) -> Operator
 {
-    __0.as_slice()[1..(__0.as_slice().len() - 1)].to_string().into()
+    Operator::GreaterThanOrEqual
 }
 
 fn __action44<
     'input,
 >(
-    (_, _, _): (usize, SpannedToken<'input>, usize),
-    (_, __0, _): (usize, BarePath, usize),
-) -> Flag
+    (_, n, _): (usize, SpannedToken<'input>, usize),
+) -> i64
 {
-    Flag::Shorthand(__0.to_string())
+    i64::from_str(n.as_slice()).unwrap()
 }
 
 fn __action45<
     'input,
 >(
-    (_, _, _): (usize, SpannedToken<'input>, usize),
-    (_, __0, _): (usize, BarePath, usize),
-) -> Flag
+    (_, l, _): (usize, usize, usize),
+    (_, num, _): (usize, i64, usize),
+    (_, unit, _): (usize, SpannedToken<'input>, usize),
+    (_, r, _): (usize, usize, usize),
+) -> Expression
 {
-    Flag::Longhand(__0.to_string())
+    ExpressionBuilder::spanned_unit((num, Unit::from_str(unit.as_slice()).unwrap()), l, r)
 }
 
 fn __action46<
     'input,
 >(
-    (_, _, _): (usize, SpannedToken<'input>, usize),
-    (_, __0, _): (usize, SpannedToken<'input>, usize),
+    (_, l, _): (usize, usize, usize),
+    (_, s, _): (usize, SpannedToken<'input>, usize),
+    (_, r, _): (usize, usize, usize),
 ) -> Expression
 {
-    Variable::from_str(__0.as_slice()).into()
+    ExpressionBuilder::spanned_string(&s.as_slice()[1..(s.as_slice().len() - 1)], l, r)
 }
 
 fn __action47<
     'input,
+>(
+    (_, l, _): (usize, usize, usize),
+    (_, s, _): (usize, SpannedToken<'input>, usize),
+    (_, r, _): (usize, usize, usize),
+) -> Expression
+{
+    ExpressionBuilder::spanned_string(&s.as_slice()[1..(s.as_slice().len() - 1)], l, r)
+}
+
+fn __action48<
+    'input,
+>(
+    (_, l, _): (usize, usize, usize),
+    (_, _, _): (usize, SpannedToken<'input>, usize),
+    (_, b, _): (usize, Bare, usize),
+    (_, r, _): (usize, usize, usize),
+) -> Expression
+{
+    ExpressionBuilder::spanned_shorthand(b.to_string(), l, r)
+}
+
+fn __action49<
+    'input,
+>(
+    (_, l, _): (usize, usize, usize),
+    (_, _, _): (usize, SpannedToken<'input>, usize),
+    (_, b, _): (usize, Bare, usize),
+    (_, r, _): (usize, usize, usize),
+) -> Expression
+{
+    ExpressionBuilder::spanned_flag(b.to_string(), l, r)
+}
+
+fn __action50<
+    'input,
+>(
+    (_, l, _): (usize, usize, usize),
+    (_, _, _): (usize, SpannedToken<'input>, usize),
+    (_, v, _): (usize, SpannedToken<'input>, usize),
+    (_, r, _): (usize, usize, usize),
+) -> Expression
+{
+    ExpressionBuilder::spanned_var(v.as_slice(), l, r)
+}
+
+fn __action51<
+    'input,
+>(
+    (_, __0, _): (usize, SpannedToken<'input>, usize),
+) -> ::std::vec::Vec<SpannedToken<'input>>
+{
+    vec![__0]
+}
+
+fn __action52<
+    'input,
+>(
+    (_, v, _): (usize, ::std::vec::Vec<SpannedToken<'input>>, usize),
+    (_, e, _): (usize, SpannedToken<'input>, usize),
+) -> ::std::vec::Vec<SpannedToken<'input>>
+{
+    { let mut v = v; v.push(e); v }
+}
+
+fn __action53<
+    'input,
+>(
+    (_, _, _): (usize, SpannedToken<'input>, usize),
+    (_, __0, _): (usize, SpannedToken<'input>, usize),
+) -> SpannedToken<'input>
+{
+    (__0)
+}
+
+fn __action54<
+    'input,
 >(
     (_, __0, _): (usize, Expression, usize),
 ) -> ::std::vec::Vec<Expression>
@@ -5206,7 +5955,7 @@ fn __action47<
     vec![__0]
 }
 
-fn __action48<
+fn __action55<
     'input,
 >(
     (_, v, _): (usize, ::std::vec::Vec<Expression>, usize),
@@ -5216,7 +5965,7 @@ fn __action48<
     { let mut v = v; v.push(e); v }
 }
 
-fn __action49<
+fn __action56<
     'input,
 >(
     (_, __0, _): (usize, Expression, usize),
@@ -5225,7 +5974,17 @@ fn __action49<
     (__0)
 }
 
-fn __action50<
+fn __action57<
+    'input,
+>(
+    __lookbehind: &usize,
+    __lookahead: &usize,
+) -> usize
+{
+    __lookbehind.clone()
+}
+
+fn __action58<
     'input,
 >(
     __lookbehind: &usize,
@@ -5235,7 +5994,7 @@ fn __action50<
     vec![]
 }
 
-fn __action51<
+fn __action59<
     'input,
 >(
     (_, v, _): (usize, ::std::vec::Vec<Expression>, usize),
@@ -5244,7 +6003,7 @@ fn __action51<
     v
 }
 
-fn __action52<
+fn __action60<
     'input,
 >(
     (_, _, _): (usize, SpannedToken<'input>, usize),
@@ -5254,7 +6013,17 @@ fn __action52<
     (__0)
 }
 
-fn __action53<
+fn __action61<
+    'input,
+>(
+    __lookbehind: &usize,
+    __lookahead: &usize,
+) -> usize
+{
+    __lookahead.clone()
+}
+
+fn __action62<
     'input,
 >(
     (_, __0, _): (usize, Expression, usize),
@@ -5263,7 +6032,7 @@ fn __action53<
     vec![__0]
 }
 
-fn __action54<
+fn __action63<
     'input,
 >(
     (_, v, _): (usize, ::std::vec::Vec<Expression>, usize),
@@ -5273,7 +6042,47 @@ fn __action54<
     { let mut v = v; v.push(e); v }
 }
 
-fn __action55<
+fn __action64<
+    'input,
+>(
+    __0: (usize, SpannedToken<'input>, usize),
+    __1: (usize, SpannedToken<'input>, usize),
+) -> ::std::vec::Vec<SpannedToken<'input>>
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __1.2.clone();
+    let __temp0 = __action53(
+        __0,
+        __1,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action51(
+        __temp0,
+    )
+}
+
+fn __action65<
+    'input,
+>(
+    __0: (usize, ::std::vec::Vec<SpannedToken<'input>>, usize),
+    __1: (usize, SpannedToken<'input>, usize),
+    __2: (usize, SpannedToken<'input>, usize),
+) -> ::std::vec::Vec<SpannedToken<'input>>
+{
+    let __start0 = __1.0.clone();
+    let __end0 = __2.2.clone();
+    let __temp0 = __action53(
+        __1,
+        __2,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action52(
+        __0,
+        __temp0,
+    )
+}
+
+fn __action66<
     'input,
 >(
     __0: (usize, SpannedToken<'input>, usize),
@@ -5282,17 +6091,17 @@ fn __action55<
 {
     let __start0 = __0.0.clone();
     let __end0 = __1.2.clone();
-    let __temp0 = __action52(
+    let __temp0 = __action60(
         __0,
         __1,
     );
     let __temp0 = (__start0, __temp0, __end0);
-    __action53(
+    __action62(
         __temp0,
     )
 }
 
-fn __action56<
+fn __action67<
     'input,
 >(
     __0: (usize, ::std::vec::Vec<Expression>, usize),
@@ -5302,56 +6111,64 @@ fn __action56<
 {
     let __start0 = __1.0.clone();
     let __end0 = __2.2.clone();
-    let __temp0 = __action52(
+    let __temp0 = __action60(
         __1,
         __2,
     );
     let __temp0 = (__start0, __temp0, __end0);
-    __action54(
+    __action63(
         __0,
         __temp0,
     )
 }
 
-fn __action57<
+fn __action68<
     'input,
 >(
-    __0: (usize, Expression, usize),
+    __0: (usize, usize, usize),
+    __1: (usize, Expression, usize),
+    __2: (usize, usize, usize),
 ) -> Pipeline
 {
-    let __start0 = __0.2.clone();
-    let __end0 = __0.2.clone();
-    let __temp0 = __action50(
+    let __start0 = __1.2.clone();
+    let __end0 = __2.0.clone();
+    let __temp0 = __action58(
         &__start0,
         &__end0,
     );
     let __temp0 = (__start0, __temp0, __end0);
     __action2(
         __0,
+        __1,
         __temp0,
+        __2,
     )
 }
 
-fn __action58<
+fn __action69<
     'input,
 >(
-    __0: (usize, Expression, usize),
-    __1: (usize, ::std::vec::Vec<Expression>, usize),
+    __0: (usize, usize, usize),
+    __1: (usize, Expression, usize),
+    __2: (usize, ::std::vec::Vec<Expression>, usize),
+    __3: (usize, usize, usize),
 ) -> Pipeline
 {
-    let __start0 = __1.0.clone();
-    let __end0 = __1.2.clone();
-    let __temp0 = __action51(
-        __1,
+    let __start0 = __2.0.clone();
+    let __end0 = __2.2.clone();
+    let __temp0 = __action59(
+        __2,
     );
     let __temp0 = (__start0, __temp0, __end0);
     __action2(
         __0,
+        __1,
         __temp0,
+        __3,
     )
 }
 
-fn __action59<
+fn __action70<
     'input,
 >(
     __0: (usize, Expression, usize),
@@ -5359,16 +6176,16 @@ fn __action59<
 {
     let __start0 = __0.0.clone();
     let __end0 = __0.2.clone();
-    let __temp0 = __action49(
+    let __temp0 = __action56(
         __0,
     );
     let __temp0 = (__start0, __temp0, __end0);
-    __action47(
+    __action54(
         __temp0,
     )
 }
 
-fn __action60<
+fn __action71<
     'input,
 >(
     __0: (usize, ::std::vec::Vec<Expression>, usize),
@@ -5377,16 +6194,1032 @@ fn __action60<
 {
     let __start0 = __1.0.clone();
     let __end0 = __1.2.clone();
-    let __temp0 = __action49(
+    let __temp0 = __action56(
         __1,
     );
     let __temp0 = (__start0, __temp0, __end0);
-    __action48(
+    __action55(
         __0,
         __temp0,
     )
 }
 
+fn __action72<
+    'input,
+>(
+    __0: (usize, Bare, usize),
+    __1: (usize, usize, usize),
+) -> Expression
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action32(
+        __temp0,
+        __0,
+        __1,
+    )
+}
+
+fn __action73<
+    'input,
+>(
+    __0: (usize, Expression, usize),
+    __1: (usize, Spanned<Operator>, usize),
+    __2: (usize, Expression, usize),
+    __3: (usize, usize, usize),
+) -> Expression
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action13(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
+}
+
+fn __action74<
+    'input,
+>(
+    __0: (usize, SpannedToken<'input>, usize),
+    __1: (usize, Expression, usize),
+    __2: (usize, SpannedToken<'input>, usize),
+    __3: (usize, usize, usize),
+) -> Expression
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action14(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
+}
+
+fn __action75<
+    'input,
+>(
+    __0: (usize, SpannedToken<'input>, usize),
+    __1: (usize, Expression, usize),
+    __2: (usize, SpannedToken<'input>, usize),
+    __3: (usize, usize, usize),
+) -> Expression
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action15(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
+}
+
+fn __action76<
+    'input,
+>(
+    __0: (usize, Expression, usize),
+    __1: (usize, Expression, usize),
+    __2: (usize, usize, usize),
+) -> Expression
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action9(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
+}
+
+fn __action77<
+    'input,
+>(
+    __0: (usize, Expression, usize),
+    __1: (usize, Expression, usize),
+    __2: (usize, ::std::vec::Vec<Expression>, usize),
+    __3: (usize, usize, usize),
+) -> Expression
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action10(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
+}
+
+fn __action78<
+    'input,
+>(
+    __0: (usize, Expression, usize),
+    __1: (usize, Expression, usize),
+    __2: (usize, usize, usize),
+) -> Expression
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action11(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
+}
+
+fn __action79<
+    'input,
+>(
+    __0: (usize, Expression, usize),
+    __1: (usize, Expression, usize),
+    __2: (usize, ::std::vec::Vec<Expression>, usize),
+    __3: (usize, usize, usize),
+) -> Expression
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action12(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
+}
+
+fn __action80<
+    'input,
+>(
+    __0: (usize, Expression, usize),
+    __1: (usize, ::std::vec::Vec<SpannedToken<'input>>, usize),
+    __2: (usize, usize, usize),
+) -> Expression
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action22(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
+}
+
+fn __action81<
+    'input,
+>(
+    __0: (usize, SpannedToken<'input>, usize),
+    __1: (usize, Bare, usize),
+    __2: (usize, usize, usize),
+) -> Expression
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action48(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
+}
+
+fn __action82<
+    'input,
+>(
+    __0: (usize, SpannedToken<'input>, usize),
+    __1: (usize, Bare, usize),
+    __2: (usize, usize, usize),
+) -> Expression
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action49(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
+}
+
+fn __action83<
+    'input,
+>(
+    __0: (usize, i64, usize),
+    __1: (usize, usize, usize),
+) -> Expression
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action6(
+        __temp0,
+        __0,
+        __1,
+    )
+}
+
+fn __action84<
+    'input,
+>(
+    __0: (usize, SpannedToken<'input>, usize),
+    __1: (usize, Expression, usize),
+    __2: (usize, SpannedToken<'input>, usize),
+    __3: (usize, usize, usize),
+) -> Expression
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action18(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
+}
+
+fn __action85<
+    'input,
+>(
+    __0: (usize, SpannedToken<'input>, usize),
+    __1: (usize, Expression, usize),
+    __2: (usize, SpannedToken<'input>, usize),
+    __3: (usize, usize, usize),
+) -> Expression
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action19(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
+}
+
+fn __action86<
+    'input,
+>(
+    __0: (usize, SpannedToken<'input>, usize),
+    __1: (usize, Expression, usize),
+    __2: (usize, SpannedToken<'input>, usize),
+    __3: (usize, usize, usize),
+) -> Expression
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action20(
+        __temp0,
+        __0,
+        __1,
+        __2,
+        __3,
+    )
+}
+
+fn __action87<
+    'input,
+>(
+    __0: (usize, Expression, usize),
+    __1: (usize, usize, usize),
+) -> Pipeline
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action68(
+        __temp0,
+        __0,
+        __1,
+    )
+}
+
+fn __action88<
+    'input,
+>(
+    __0: (usize, Expression, usize),
+    __1: (usize, ::std::vec::Vec<Expression>, usize),
+    __2: (usize, usize, usize),
+) -> Pipeline
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action69(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
+}
+
+fn __action89<
+    'input,
+>(
+    __0: (usize, Expression, usize),
+    __1: (usize, usize, usize),
+) -> Expression
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action3(
+        __temp0,
+        __0,
+        __1,
+    )
+}
+
+fn __action90<
+    'input,
+>(
+    __0: (usize, Operator, usize),
+    __1: (usize, usize, usize),
+) -> Spanned<Operator>
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action33(
+        __temp0,
+        __0,
+        __1,
+    )
+}
+
+fn __action91<
+    'input,
+>(
+    __0: (usize, SpannedToken<'input>, usize),
+    __1: (usize, usize, usize),
+) -> Expression
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action46(
+        __temp0,
+        __0,
+        __1,
+    )
+}
+
+fn __action92<
+    'input,
+>(
+    __0: (usize, SpannedToken<'input>, usize),
+    __1: (usize, usize, usize),
+) -> Expression
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action47(
+        __temp0,
+        __0,
+        __1,
+    )
+}
+
+fn __action93<
+    'input,
+>(
+    __0: (usize, i64, usize),
+    __1: (usize, SpannedToken<'input>, usize),
+    __2: (usize, usize, usize),
+) -> Expression
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action45(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
+}
+
+fn __action94<
+    'input,
+>(
+    __0: (usize, SpannedToken<'input>, usize),
+    __1: (usize, SpannedToken<'input>, usize),
+    __2: (usize, usize, usize),
+) -> Expression
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __0.0.clone();
+    let __temp0 = __action61(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action50(
+        __temp0,
+        __0,
+        __1,
+        __2,
+    )
+}
+
+fn __action95<
+    'input,
+>(
+    __0: (usize, Bare, usize),
+) -> Expression
+{
+    let __start0 = __0.2.clone();
+    let __end0 = __0.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action72(
+        __0,
+        __temp0,
+    )
+}
+
+fn __action96<
+    'input,
+>(
+    __0: (usize, Expression, usize),
+    __1: (usize, Spanned<Operator>, usize),
+    __2: (usize, Expression, usize),
+) -> Expression
+{
+    let __start0 = __2.2.clone();
+    let __end0 = __2.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action73(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
+}
+
+fn __action97<
+    'input,
+>(
+    __0: (usize, SpannedToken<'input>, usize),
+    __1: (usize, Expression, usize),
+    __2: (usize, SpannedToken<'input>, usize),
+) -> Expression
+{
+    let __start0 = __2.2.clone();
+    let __end0 = __2.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action74(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
+}
+
+fn __action98<
+    'input,
+>(
+    __0: (usize, SpannedToken<'input>, usize),
+    __1: (usize, Expression, usize),
+    __2: (usize, SpannedToken<'input>, usize),
+) -> Expression
+{
+    let __start0 = __2.2.clone();
+    let __end0 = __2.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action75(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
+}
+
+fn __action99<
+    'input,
+>(
+    __0: (usize, Expression, usize),
+    __1: (usize, Expression, usize),
+) -> Expression
+{
+    let __start0 = __1.2.clone();
+    let __end0 = __1.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action76(
+        __0,
+        __1,
+        __temp0,
+    )
+}
+
+fn __action100<
+    'input,
+>(
+    __0: (usize, Expression, usize),
+    __1: (usize, Expression, usize),
+    __2: (usize, ::std::vec::Vec<Expression>, usize),
+) -> Expression
+{
+    let __start0 = __2.2.clone();
+    let __end0 = __2.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action77(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
+}
+
+fn __action101<
+    'input,
+>(
+    __0: (usize, Expression, usize),
+    __1: (usize, Expression, usize),
+) -> Expression
+{
+    let __start0 = __1.2.clone();
+    let __end0 = __1.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action78(
+        __0,
+        __1,
+        __temp0,
+    )
+}
+
+fn __action102<
+    'input,
+>(
+    __0: (usize, Expression, usize),
+    __1: (usize, Expression, usize),
+    __2: (usize, ::std::vec::Vec<Expression>, usize),
+) -> Expression
+{
+    let __start0 = __2.2.clone();
+    let __end0 = __2.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action79(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
+}
+
+fn __action103<
+    'input,
+>(
+    __0: (usize, Expression, usize),
+    __1: (usize, ::std::vec::Vec<SpannedToken<'input>>, usize),
+) -> Expression
+{
+    let __start0 = __1.2.clone();
+    let __end0 = __1.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action80(
+        __0,
+        __1,
+        __temp0,
+    )
+}
+
+fn __action104<
+    'input,
+>(
+    __0: (usize, SpannedToken<'input>, usize),
+    __1: (usize, Bare, usize),
+) -> Expression
+{
+    let __start0 = __1.2.clone();
+    let __end0 = __1.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action81(
+        __0,
+        __1,
+        __temp0,
+    )
+}
+
+fn __action105<
+    'input,
+>(
+    __0: (usize, SpannedToken<'input>, usize),
+    __1: (usize, Bare, usize),
+) -> Expression
+{
+    let __start0 = __1.2.clone();
+    let __end0 = __1.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action82(
+        __0,
+        __1,
+        __temp0,
+    )
+}
+
+fn __action106<
+    'input,
+>(
+    __0: (usize, i64, usize),
+) -> Expression
+{
+    let __start0 = __0.2.clone();
+    let __end0 = __0.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action83(
+        __0,
+        __temp0,
+    )
+}
+
+fn __action107<
+    'input,
+>(
+    __0: (usize, SpannedToken<'input>, usize),
+    __1: (usize, Expression, usize),
+    __2: (usize, SpannedToken<'input>, usize),
+) -> Expression
+{
+    let __start0 = __2.2.clone();
+    let __end0 = __2.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action84(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
+}
+
+fn __action108<
+    'input,
+>(
+    __0: (usize, SpannedToken<'input>, usize),
+    __1: (usize, Expression, usize),
+    __2: (usize, SpannedToken<'input>, usize),
+) -> Expression
+{
+    let __start0 = __2.2.clone();
+    let __end0 = __2.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action85(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
+}
+
+fn __action109<
+    'input,
+>(
+    __0: (usize, SpannedToken<'input>, usize),
+    __1: (usize, Expression, usize),
+    __2: (usize, SpannedToken<'input>, usize),
+) -> Expression
+{
+    let __start0 = __2.2.clone();
+    let __end0 = __2.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action86(
+        __0,
+        __1,
+        __2,
+        __temp0,
+    )
+}
+
+fn __action110<
+    'input,
+>(
+    __0: (usize, Expression, usize),
+) -> Pipeline
+{
+    let __start0 = __0.2.clone();
+    let __end0 = __0.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action87(
+        __0,
+        __temp0,
+    )
+}
+
+fn __action111<
+    'input,
+>(
+    __0: (usize, Expression, usize),
+    __1: (usize, ::std::vec::Vec<Expression>, usize),
+) -> Pipeline
+{
+    let __start0 = __1.2.clone();
+    let __end0 = __1.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action88(
+        __0,
+        __1,
+        __temp0,
+    )
+}
+
+fn __action112<
+    'input,
+>(
+    __0: (usize, Expression, usize),
+) -> Expression
+{
+    let __start0 = __0.2.clone();
+    let __end0 = __0.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action89(
+        __0,
+        __temp0,
+    )
+}
+
+fn __action113<
+    'input,
+>(
+    __0: (usize, Operator, usize),
+) -> Spanned<Operator>
+{
+    let __start0 = __0.2.clone();
+    let __end0 = __0.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action90(
+        __0,
+        __temp0,
+    )
+}
+
+fn __action114<
+    'input,
+>(
+    __0: (usize, SpannedToken<'input>, usize),
+) -> Expression
+{
+    let __start0 = __0.2.clone();
+    let __end0 = __0.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action91(
+        __0,
+        __temp0,
+    )
+}
+
+fn __action115<
+    'input,
+>(
+    __0: (usize, SpannedToken<'input>, usize),
+) -> Expression
+{
+    let __start0 = __0.2.clone();
+    let __end0 = __0.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action92(
+        __0,
+        __temp0,
+    )
+}
+
+fn __action116<
+    'input,
+>(
+    __0: (usize, i64, usize),
+    __1: (usize, SpannedToken<'input>, usize),
+) -> Expression
+{
+    let __start0 = __1.2.clone();
+    let __end0 = __1.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action93(
+        __0,
+        __1,
+        __temp0,
+    )
+}
+
+fn __action117<
+    'input,
+>(
+    __0: (usize, SpannedToken<'input>, usize),
+    __1: (usize, SpannedToken<'input>, usize),
+) -> Expression
+{
+    let __start0 = __1.2.clone();
+    let __end0 = __1.2.clone();
+    let __temp0 = __action57(
+        &__start0,
+        &__end0,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action94(
+        __0,
+        __1,
+        __temp0,
+    )
+}
+
 pub trait __ToTriple<'input, > {
     fn to_triple(value: Self) -> Result<(usize,SpannedToken<'input>,usize), __lalrpop_util::ParseError<usize, SpannedToken<'input>, ShellError>>;
 }
diff --git a/src/parser/registry.rs b/src/parser/registry.rs
index 11fbcfa65..84fedce19 100644
--- a/src/parser/registry.rs
+++ b/src/parser/registry.rs
@@ -41,21 +41,31 @@ impl PositionalType {
         match self {
             PositionalType::Value(_) => evaluate_expr(&arg, scope),
             PositionalType::Block(_) => match arg {
-                ast::Expression::Block(b) => Ok(Value::block(b.expr)),
-                ast::Expression::Binary(b) => {
-                    if let Some(s) = b.left.as_string() {
-                        Ok(Value::block(ast::Expression::Binary(Box::new(
-                            ast::Binary::new(
-                                ast::Expression::Path(Box::new(ast::Path::new(
-                                    ast::Expression::VariableReference(ast::Variable::It),
-                                    vec![s],
-                                ))),
-                                b.operator,
-                                b.right,
-                            ),
+                ast::Expression {
+                    expr: ast::RawExpression::Block(b),
+                    ..
+                } => Ok(Value::block(b.expr)),
+                ast::Expression {
+                    expr: ast::RawExpression::Binary(binary),
+                    ..
+                } => {
+                    // TODO: Use original spans
+                    let mut b = ast::ExpressionBuilder::new();
+                    if let Some(s) = binary.left.as_string() {
+                        Ok(Value::block(b.binary((
+                            &|b| b.path((&|b| b.var("it"), vec![s.clone()])),
+                            &|_| binary.operator.clone(),
+                            &|_| binary.right.clone(),
                         ))))
                     } else {
-                        Ok(Value::block(ast::Expression::Binary(b)))
+                        let mut b = ast::ExpressionBuilder::new();
+                        let expr = b.binary((
+                            &|_| binary.left.clone(),
+                            &|_| binary.operator.clone(),
+                            &|_| binary.right.clone(),
+                        ));
+
+                        Ok(Value::block(expr))
                     }
                 }
                 other => Ok(Value::block(other)), // other =>
@@ -192,13 +202,13 @@ fn extract_named(
 }
 
 fn expect_simple_expr(expr: ast::Expression) -> Result<Value, ShellError> {
-    match expr {
-        ast::Expression::Leaf(l) => Ok(match l {
+    match &*expr {
+        ast::RawExpression::Leaf(l) => Ok(match l {
             ast::Leaf::Bare(s) => Value::string(s.to_string()),
             ast::Leaf::String(s) => Value::string(s),
-            ast::Leaf::Boolean(b) => Value::boolean(b),
-            ast::Leaf::Int(i) => Value::int(i),
-            ast::Leaf::Unit(i, unit) => unit.compute(i),
+            ast::Leaf::Boolean(b) => Value::boolean(*b),
+            ast::Leaf::Int(i) => Value::int(*i),
+            ast::Leaf::Unit(i, unit) => unit.compute(*i),
         }),
 
         // TODO: Diagnostic