(CommandList
  children: [
    (AndOr
      ops: [Op_DAmp]
      children: [
        (C {(Lit_Other '[')} 
          {
            (BracedVarSub
              token: <VSub_Name PARSER_SH>
              suffix_op: (StringUnary op_id:VTest_Plus arg_word:{(true)})
              spids: [9 13]
            )
          } {(Lit_Other ']')}
        )
        (ControlFlow token:<ControlFlow_Return return>)
      ]
    )
    (Assignment
      keyword: Assign_Declare
      flags: [-g]
      pairs: [(assign_pair lhs:(LhsName name:PARSER_SH) op:Equal rhs:{(true)} spids:[25])]
      spids: [21]
    )
    (C {(.)} 
      {
        (BracedVarSub
          token: <VSub_Name BASH_SOURCE>
          suffix_op: (StringUnary op_id:VOp1_Percent arg_word:{(Lit_Slash /) ('*')})
          spids: [31 36]
        ) (/common.sh)
      }
    )
    (C {(.)} 
      {
        (BracedVarSub
          token: <VSub_Name BASH_SOURCE>
          suffix_op: (StringUnary op_id:VOp1_Percent arg_word:{(Lit_Slash /) ('*')})
          spids: [41 46]
        ) (/variables.sh)
      }
    )
    (C {(.)} 
      {
        (BracedVarSub
          token: <VSub_Name BASH_SOURCE>
          suffix_op: (StringUnary op_id:VOp1_Percent arg_word:{(Lit_Slash /) ('*')})
          spids: [51 56]
        ) (/variables.linkedlist.sh)
      }
    )
    (Assignment
      keyword: Assign_Declare
      flags: [-g]
      pairs: [(assign_pair lhs:(LhsName name:PARSER_DEBUG) op:Equal rhs:{(0)} spids:[64])]
      spids: [60]
    )
    (Assignment
      keyword: Assign_Declare
      flags: [-g]
      pairs: [(assign_pair lhs:(LhsName name:PARSER_PARSED) op:Equal spids:[71])]
      spids: [67]
    )
    (Assignment
      keyword: Assign_Declare
      flags: [-g]
      pairs: [(assign_pair lhs:(LhsName name:PARSER_PARSED_COUNT) op:Equal spids:[77])]
      spids: [73]
    )
    (FuncDef
      name: 'parser::parse'
      body: 
        (BraceGroup
          children: [
            (C 
              {(parser) (Lit_Other ':') (Lit_Other ':') (parse) (Lit_Other ':') (Lit_Other ':') 
                (substring)
              } {(DQ (${ VSub_At '@'))}
            )
          ]
          spids: [89]
        )
      spids: [80 88]
    )
    (FuncDef
      name: 'parser::parse::multiExpression'
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(${ VSub_Name PARSER_DEBUG)}
                              right: {(1)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Sentence
                      child: (C {(stderr)} {(DQ (${ VSub_Name FUNCNAME) (' ') (${ VSub_At '@'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  spids: [16777215 151]
                )
              ]
              spids: [16777215 167]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:text)
                  op: Equal
                  rhs: {(DQ (${ VSub_Number 1))}
                  spids: [173]
                )
              ]
              spids: [171]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:originalOffset)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (BracedVarSub
                          token: <VSub_Number 2>
                          suffix_op: (StringUnary op_id:VTest_Hyphen arg_word:{(0)})
                          spids: [185 189]
                        )
                      )
                    }
                  spids: [183]
                )
              ]
              spids: [181]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:offset)
                  op: Equal
                  rhs: {($ VSub_Name '$originalOffset')}
                  spids: [195]
                )
              ]
              spids: [193]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(${ VSub_Name PARSER_DEBUG)}
                              right: {(1)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Sentence
                      child: 
                        (C {(stderr)} 
                          {
                            (DQ ('Trying to parse multiExpr from:\n') 
                              (BracedVarSub
                                token: <VSub_Name text>
                                suffix_op: (Slice begin:(ArithWord w:{(${ VSub_Name offset)}))
                                spids: [221 227]
                              )
                            )
                          }
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  spids: [16777215 215]
                )
              ]
              spids: [16777215 232]
            )
            (Sentence
              child: 
                (C 
                  {(variable) (Lit_Other ':') (Lit_Other ':') (LinkedList) (Lit_Other ':') 
                    (Lit_Other ':') (new)
                  }
                )
              terminator: <Op_Semi ';'>
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:items)
                  op: Equal
                  rhs: {(DQ (${ VSub_Name RESULT))}
                  spids: [281]
                )
              ]
              spids: [279]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C 
                          {(parser) (Lit_Other ':') (Lit_Other ':') (parse) (Lit_Other ':') 
                            (Lit_Other ':') (whitespace)
                          } {(DQ ($ VSub_Name '$text'))} {(${ VSub_Name offset)}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (DParen
                      child: 
                        (BinaryAssign
                          op_id: Arith_PlusEqual
                          left: (LhsName name:offset)
                          right: (ArithWord w:{(${ VSub_Name PARSER_PARSED_COUNT)})
                        )
                    )
                  ]
                  spids: [16777215 313]
                )
              ]
              spids: [16777215 330]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(parser) (Lit_Other ':') (Lit_Other ':') (parse)} {(DQ (${ VSub_Name text))} 
                          {(${ VSub_Name offset)}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C 
                      {(variable) (Lit_Other ':') (Lit_Other ':') (LinkedList) (Lit_Other ':') 
                        (Lit_Other ':') (append)
                      } {(DQ ($ VSub_Name '$items'))} {(${ VSub_Name PARSER_PARSED)}
                    )
                    (DParen
                      child: 
                        (BinaryAssign
                          op_id: Arith_PlusEqual
                          left: (LhsName name:offset)
                          right: (ArithWord w:{(${ VSub_Name PARSER_PARSED_COUNT)})
                        )
                    )
                  ]
                  spids: [16777215 356]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:PARSER_PARSED)
                      op: Equal
                      rhs: {(DQ (${ VSub_Name items))}
                      spids: [397]
                    )
                  ]
                  spids: [397]
                )
                (DParen
                  child: 
                    (BinaryAssign
                      op_id: Arith_Equal
                      left: (LhsName name:PARSER_PARSED_COUNT)
                      right: 
                        (ArithBinary
                          op_id: Arith_Minus
                          left: (ArithVarRef name:offset)
                          right: (ArithVarRef name:originalOffset)
                        )
                    )
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
              ]
              spids: [390 426]
            )
            (While
              cond: [(Sentence child:(C {(true)}) terminator:<Op_Semi ';'>)]
              body: 
                (DoGroup
                  children: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (Pipeline
                                  children: [
                                    (C 
                                      {(parser) (Lit_Other ':') (Lit_Other ':') (parse) (Lit_Other ':') 
                                        (Lit_Other ':') (whitespace)
                                      } {(DQ ($ VSub_Name '$text'))} {(${ VSub_Name offset)}
                                    )
                                  ]
                                  negated: T
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:PARSER_PARSED)
                                  op: Equal
                                  rhs: {(DQ (${ VSub_Name items))}
                                  spids: [474]
                                )
                              ]
                              spids: [474]
                            )
                            (DParen
                              child: 
                                (BinaryAssign
                                  op_id: Arith_Equal
                                  left: (LhsName name:PARSER_PARSED_COUNT)
                                  right: 
                                    (ArithBinary
                                      op_id: Arith_Minus
                                      left: (ArithVarRef name:offset)
                                      right: (ArithVarRef name:originalOffset)
                                    )
                                )
                            )
                            (ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                          spids: [16777215 467]
                        )
                      ]
                      spids: [16777215 503]
                    )
                    (Sentence
                      child: 
                        (DParen
                          child: 
                            (BinaryAssign
                              op_id: Arith_PlusEqual
                              left: (LhsName name:offset)
                              right: (ArithWord w:{(${ VSub_Name PARSER_PARSED_COUNT)})
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (Pipeline
                                  children: [
                                    (C {(parser) (Lit_Other ':') (Lit_Other ':') (parse)} 
                                      {(DQ (${ VSub_Name text))} {(${ VSub_Name offset)}
                                    )
                                  ]
                                  negated: T
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:PARSER_PARSED)
                                  op: Equal
                                  rhs: {(DQ (${ VSub_Name items))}
                                  spids: [553]
                                )
                              ]
                              spids: [553]
                            )
                            (DParen
                              child: 
                                (BinaryAssign
                                  op_id: Arith_Equal
                                  left: (LhsName name:PARSER_PARSED_COUNT)
                                  right: 
                                    (ArithBinary
                                      op_id: Arith_Minus
                                      left: (ArithVarRef name:offset)
                                      right: (ArithVarRef name:originalOffset)
                                    )
                                )
                            )
                            (ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                          spids: [16777215 546]
                        )
                      ]
                      spids: [16777215 582]
                    )
                    (C 
                      {(variable) (Lit_Other ':') (Lit_Other ':') (LinkedList) (Lit_Other ':') 
                        (Lit_Other ':') (append)
                      } {(DQ ($ VSub_Name '$items'))} {(DQ (${ VSub_Name PARSER_PARSED))}
                    )
                    (Sentence
                      child: 
                        (DParen
                          child: 
                            (BinaryAssign
                              op_id: Arith_PlusEqual
                              left: (LhsName name:offset)
                              right: (ArithWord w:{(${ VSub_Name PARSER_PARSED_COUNT)})
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  spids: [443 626]
                )
            )
            (C {(stderr)} {(DQ ('Should never get here'))})
            (ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
          ]
          spids: [133]
        )
      spids: [121 132]
    )
    (FuncDef
      name: 'parser::parse::substring'
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(${ VSub_Name PARSER_DEBUG)}
                              right: {(1)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Sentence
                      child: (C {(stderr)} {(DQ (${ VSub_Name FUNCNAME) (' ') (${ VSub_At '@'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  spids: [16777215 674]
                )
              ]
              spids: [16777215 690]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:text)
                  op: Equal
                  rhs: {(DQ (${ VSub_Number 1))}
                  spids: [696]
                )
              ]
              spids: [694]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:offset)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (BracedVarSub
                          token: <VSub_Number 2>
                          suffix_op: (StringUnary op_id:VTest_Hyphen arg_word:{(0)})
                          spids: [708 712]
                        )
                      )
                    }
                  spids: [706]
                )
              ]
              spids: [704]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C 
                          {(parser) (Lit_Other ':') (Lit_Other ':') (parse) (Lit_Other ':') 
                            (Lit_Other ':') (atom)
                          } {(DQ (${ VSub_Name text))} {(DQ (${ VSub_Name offset))}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:PARSER_PARSED)
                          op: Equal
                          rhs: {(DQ (${ VSub_Name PARSER_PARSED))}
                          spids: [747]
                        )
                      ]
                      spids: [747]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:PARSER_PARSED_COUNT)
                          op: Equal
                          rhs: {(DQ (${ VSub_Name PARSER_PARSED_COUNT))}
                          spids: [755]
                        )
                      ]
                      spids: [755]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [16777215 740]
                )
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C 
                          {(parser) (Lit_Other ':') (Lit_Other ':') (parse) (Lit_Other ':') 
                            (Lit_Other ':') (sexp)
                          } {(DQ (${ VSub_Name text))} {(DQ (${ VSub_Name offset))}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:PARSER_PARSED)
                          op: Equal
                          rhs: {(DQ (${ VSub_Name PARSER_PARSED))}
                          spids: [798]
                        )
                      ]
                      spids: [798]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:PARSER_PARSED_COUNT)
                          op: Equal
                          rhs: {(DQ (${ VSub_Name PARSER_PARSED_COUNT))}
                          spids: [806]
                        )
                      ]
                      spids: [806]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [768 791]
                )
              ]
              spids: [16777215 819]
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
          spids: [656]
        )
      spids: [644 655]
    )
    (FuncDef
      name: 'parser::parse::atom'
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(${ VSub_Name PARSER_DEBUG)}
                              right: {(1)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Sentence
                      child: (C {(stderr)} {(DQ (${ VSub_Name FUNCNAME) (' ') (${ VSub_At '@'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  spids: [16777215 866]
                )
              ]
              spids: [16777215 882]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C 
                          {(parser) (Lit_Other ':') (Lit_Other ':') (parse) (Lit_Other ':') 
                            (Lit_Other ':') (real)
                          } {(DQ (${ VSub_Name text))} {(DQ (${ VSub_Name offset))}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:PARSER_PARSED)
                          op: Equal
                          rhs: {(DQ (${ VSub_Name PARSER_PARSED))}
                          spids: [916]
                        )
                      ]
                      spids: [916]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:PARSER_PARSED_COUNT)
                          op: Equal
                          rhs: {(DQ (${ VSub_Name PARSER_PARSED_COUNT))}
                          spids: [924]
                        )
                      ]
                      spids: [924]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [16777215 909]
                )
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C 
                          {(parser) (Lit_Other ':') (Lit_Other ':') (parse) (Lit_Other ':') 
                            (Lit_Other ':') (integer)
                          } {(DQ (${ VSub_Name text))} {(DQ (${ VSub_Name offset))}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:PARSER_PARSED)
                          op: Equal
                          rhs: {(DQ (${ VSub_Name PARSER_PARSED))}
                          spids: [967]
                        )
                      ]
                      spids: [967]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:PARSER_PARSED_COUNT)
                          op: Equal
                          rhs: {(DQ (${ VSub_Name PARSER_PARSED_COUNT))}
                          spids: [975]
                        )
                      ]
                      spids: [975]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [937 960]
                )
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C 
                          {(parser) (Lit_Other ':') (Lit_Other ':') (parse) (Lit_Other ':') 
                            (Lit_Other ':') (identifier)
                          } {(DQ (${ VSub_Name text))} {(DQ (${ VSub_Name offset))}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:PARSER_PARSED)
                          op: Equal
                          rhs: {(DQ (${ VSub_Name PARSER_PARSED))}
                          spids: [1018]
                        )
                      ]
                      spids: [1018]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:PARSER_PARSED_COUNT)
                          op: Equal
                          rhs: {(DQ (${ VSub_Name PARSER_PARSED_COUNT))}
                          spids: [1026]
                        )
                      ]
                      spids: [1026]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [988 1011]
                )
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C 
                          {(parser) (Lit_Other ':') (Lit_Other ':') (parse) (Lit_Other ':') 
                            (Lit_Other ':') (string)
                          } {(DQ (${ VSub_Name text))} {(DQ (${ VSub_Name offset))}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:PARSER_PARSED)
                          op: Equal
                          rhs: {(DQ (${ VSub_Name PARSER_PARSED))}
                          spids: [1069]
                        )
                      ]
                      spids: [1069]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:PARSER_PARSED_COUNT)
                          op: Equal
                          rhs: {(DQ (${ VSub_Name PARSER_PARSED_COUNT))}
                          spids: [1077]
                        )
                      ]
                      spids: [1077]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [1039 1062]
                )
              ]
              spids: [16777215 1090]
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
          spids: [848]
        )
      spids: [836 847]
    )
    (FuncDef
      name: 'parser::parse::real'
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(${ VSub_Name PARSER_DEBUG)}
                              right: {(1)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Sentence
                      child: (C {(stderr)} {(DQ (${ VSub_Name FUNCNAME) (' ') (${ VSub_At '@'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  spids: [16777215 1130]
                )
              ]
              spids: [16777215 1146]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(${ VSub_Name PARSER_DEBUG)}
                              right: {(1)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Sentence
                      child: 
                        (C {(stderr)} 
                          {
                            (DQ ('Trying to parse real from:\n') 
                              (BracedVarSub
                                token: <VSub_Name text>
                                suffix_op: (Slice begin:(ArithWord w:{(${ VSub_Name offset)}))
                                spids: [1170 1176]
                              )
                            )
                          }
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  spids: [16777215 1164]
                )
              ]
              spids: [16777215 1181]
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
          spids: [1112]
        )
      spids: [1100 1111]
    )
    (Assignment
      keyword: Assign_Declare
      flags: [-g]
      pairs: [
        (assign_pair
          lhs: (LhsName name:PARSER_INTEGER_REGEX)
          op: Equal
          rhs: {(SQ <'\\(-\\?[1-9][0-9]*\\)'>)}
          spids: [1204]
        )
      ]
      spids: [1200]
    )
    (Assignment
      keyword: Assign_Declare
      flags: [-g]
      pairs: [
        (assign_pair
          lhs: (LhsName name:PARSER_INTEGER_0_REGEX)
          op: Equal
          rhs: {(SQ <'\\(0\\)'>)}
          spids: [1213]
        )
      ]
      spids: [1209]
    )
    (FuncDef
      name: 'parser::parse::integer'
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(${ VSub_Name PARSER_DEBUG)}
                              right: {(1)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Sentence
                      child: (C {(stderr)} {(DQ (${ VSub_Name FUNCNAME) (' ') (${ VSub_At '@'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  spids: [16777215 1248]
                )
              ]
              spids: [16777215 1264]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:text)
                  op: Equal
                  rhs: {(DQ (${ VSub_Number 1))}
                  spids: [1270]
                )
              ]
              spids: [1268]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:offset)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (BracedVarSub
                          token: <VSub_Number 2>
                          suffix_op: (StringUnary op_id:VTest_Hyphen arg_word:{(0)})
                          spids: [1282 1286]
                        )
                      )
                    }
                  spids: [1280]
                )
              ]
              spids: [1278]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:subtext)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (BracedVarSub
                          token: <VSub_Number 1>
                          suffix_op: (Slice begin:(ArithWord w:{(${ VSub_Name offset)}))
                          spids: [1294 1300]
                        )
                      )
                    }
                  spids: [1292]
                )
              ]
              spids: [1290]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(${ VSub_Name PARSER_DEBUG)}
                              right: {(1)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Sentence
                      child: 
                        (C {(stderr)} 
                          {
                            (DQ ('Trying to parse integer from:\n') 
                              (BracedVarSub
                                token: <VSub_Name text>
                                suffix_op: (Slice begin:(ArithWord w:{(${ VSub_Name offset)}))
                                spids: [1326 1332]
                              )
                            )
                          }
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  spids: [16777215 1320]
                )
              ]
              spids: [16777215 1337]
            )
            (Sentence
              child: 
                (Assignment
                  keyword: Assign_Declare
                  pairs: [(assign_pair lhs:(LhsName name:value) op:Equal spids:[1343])]
                  spids: [1341]
                )
              terminator: <Op_Semi ';'>
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:value)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(expr)} {(match)} {(DQ (${ VSub_Name subtext))} 
                                {($ VSub_Name '$PARSER_INTEGER_REGEX')}
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1348 1360]
                      )
                    }
                  spids: [1347]
                )
              ]
              spids: [1347]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {($ VSub_QMark '$?')}
                              right: {(0)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(variable) (Lit_Other ':') (Lit_Other ':') (new)} {(Integer)} 
                      {(DQ (${ VSub_Name value))}
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:PARSER_PARSED)
                          op: Equal
                          rhs: {(DQ (${ VSub_Name RESULT))}
                          spids: [1393]
                        )
                      ]
                      spids: [1393]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:PARSER_PARSED_COUNT)
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (BracedVarSub
                                  token: <VSub_Name value>
                                  prefix_op: VSub_Pound
                                  spids: [1403 1406]
                                )
                              )
                            }
                          spids: [1401]
                        )
                      ]
                      spids: [1401]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [16777215 1376]
                )
              ]
              spids: [16777215 1415]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: 
                                {
                                  (DQ 
                                    (BracedVarSub
                                      token: <VSub_Name subtext>
                                      suffix_op: 
                                        (Slice
                                          begin: (ArithWord w:{(Lit_Digits 0)})
                                          length: (ArithWord w:{(Lit_Digits 1)})
                                        )
                                      spids: [1424 1430]
                                    )
                                  )
                                }
                              right: {(DQ (0))}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(variable) (Lit_Other ':') (Lit_Other ':') (new)} {(Integer)} {(DQ (0))})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:PARSER_PARSED)
                          op: Equal
                          rhs: {(DQ (${ VSub_Name RESULT))}
                          spids: [1457]
                        )
                      ]
                      spids: [1457]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:PARSER_PARSED_COUNT)
                          op: Equal
                          rhs: {(1)}
                          spids: [1465]
                        )
                      ]
                      spids: [1465]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [16777215 1442]
                )
              ]
              spids: [16777215 1474]
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
          spids: [1230]
        )
      spids: [1218 1229]
    )
    (Assignment
      keyword: Assign_Declare
      flags: [-g]
      pairs: [
        (assign_pair
          lhs: (LhsName name:PARSER_IDENTIFIER_REGEX)
          op: Equal
          rhs: {(SQ <'\\([a-zA-Z!?*+<=>_:-][a-zA-Z0-9!?*+<=>_:-]*\\)'>)}
          spids: [1498]
        )
      ]
      spids: [1494]
    )
    (FuncDef
      name: 'parser::parse::identifier'
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(${ VSub_Name PARSER_DEBUG)}
                              right: {(1)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Sentence
                      child: (C {(stderr)} {(DQ (${ VSub_Name FUNCNAME) (' ') (${ VSub_At '@'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  spids: [16777215 1533]
                )
              ]
              spids: [16777215 1549]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:text)
                  op: Equal
                  rhs: {(DQ (${ VSub_Number 1))}
                  spids: [1555]
                )
              ]
              spids: [1553]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:offset)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (BracedVarSub
                          token: <VSub_Number 2>
                          suffix_op: (StringUnary op_id:VTest_Hyphen arg_word:{(0)})
                          spids: [1567 1571]
                        )
                      )
                    }
                  spids: [1565]
                )
              ]
              spids: [1563]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:subtext)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (BracedVarSub
                          token: <VSub_Number 1>
                          suffix_op: (Slice begin:(ArithWord w:{(${ VSub_Name offset)}))
                          spids: [1579 1585]
                        )
                      )
                    }
                  spids: [1577]
                )
              ]
              spids: [1575]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(${ VSub_Name PARSER_DEBUG)}
                              right: {(1)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Sentence
                      child: 
                        (C {(stderr)} 
                          {(DQ ('Trying to parse identifier from:\n') (${ VSub_Name subtext))}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  spids: [16777215 1605]
                )
              ]
              spids: [16777215 1618]
            )
            (Sentence
              child: 
                (Assignment
                  keyword: Assign_Declare
                  pairs: [(assign_pair lhs:(LhsName name:value) op:Equal spids:[1624])]
                  spids: [1622]
                )
              terminator: <Op_Semi ';'>
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:value)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(expr)} {(match)} {(DQ (${ VSub_Name subtext))} 
                                {($ VSub_Name '$PARSER_IDENTIFIER_REGEX')}
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1629 1641]
                      )
                    }
                  spids: [1628]
                )
              ]
              spids: [1628]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {($ VSub_QMark '$?')}
                              right: {(0)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(variable) (Lit_Other ':') (Lit_Other ':') (new)} {(Identifier)} 
                      {(DQ (${ VSub_Name value))}
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:PARSER_PARSED)
                          op: Equal
                          rhs: {(DQ (${ VSub_Name RESULT))}
                          spids: [1674]
                        )
                      ]
                      spids: [1674]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:PARSER_PARSED_COUNT)
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (BracedVarSub
                                  token: <VSub_Name value>
                                  prefix_op: VSub_Pound
                                  spids: [1684 1687]
                                )
                              )
                            }
                          spids: [1682]
                        )
                      ]
                      spids: [1682]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [16777215 1657]
                )
              ]
              spids: [16777215 1696]
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
          spids: [1515]
        )
      spids: [1503 1514]
    )
    (Assignment
      keyword: Assign_Declare
      flags: [-g]
      pairs: [
        (assign_pair
          lhs: (LhsName name:PARSER_STRING_REGEX)
          op: Equal
          rhs: {(SQ <'\\([^"]*\\)'>)}
          spids: [1720]
        )
      ]
      spids: [1716]
    )
    (FuncDef
      name: 'parser::parse::string'
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(${ VSub_Name PARSER_DEBUG)}
                              right: {(1)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Sentence
                      child: (C {(stderr)} {(DQ (${ VSub_Name FUNCNAME) (' ') (${ VSub_At '@'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  spids: [16777215 1755]
                )
              ]
              spids: [16777215 1771]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:text)
                  op: Equal
                  rhs: {(DQ (${ VSub_Number 1))}
                  spids: [1777]
                )
              ]
              spids: [1775]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:offset)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (BracedVarSub
                          token: <VSub_Number 2>
                          suffix_op: (StringUnary op_id:VTest_Hyphen arg_word:{(0)})
                          spids: [1789 1793]
                        )
                      )
                    }
                  spids: [1787]
                )
              ]
              spids: [1785]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:subtext)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (BracedVarSub
                          token: <VSub_Number 1>
                          suffix_op: (Slice begin:(ArithWord w:{(${ VSub_Name offset)}))
                          spids: [1801 1807]
                        )
                      )
                    }
                  spids: [1799]
                )
              ]
              spids: [1797]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(${ VSub_Name PARSER_DEBUG)}
                              right: {(1)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Sentence
                      child: 
                        (C {(stderr)} {(DQ ('Trying to parse string from:\n') (${ VSub_Name subtext))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  spids: [16777215 1827]
                )
              ]
              spids: [16777215 1840]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobNEqual
                              left: 
                                {
                                  (DQ 
                                    (BracedVarSub
                                      token: <VSub_Name subtext>
                                      suffix_op: 
                                        (Slice
                                          begin: (ArithWord w:{(Lit_Digits 0)})
                                          length: (ArithWord w:{(Lit_Digits 1)})
                                        )
                                      spids: [1849 1855]
                                    )
                                  )
                                }
                              right: {(DQ (EscapedLiteralPart token:<Lit_EscapedChar '\\"'>))}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})]
                  spids: [16777215 1867]
                )
              ]
              spids: [16777215 1875]
            )
            (Sentence
              child: 
                (Assignment
                  keyword: Assign_Declare
                  pairs: [(assign_pair lhs:(LhsName name:value) op:Equal spids:[1881])]
                  spids: [1879]
                )
              terminator: <Op_Semi ';'>
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:value)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(expr)} {(match)} 
                                {
                                  (DQ 
                                    (BracedVarSub
                                      token: <VSub_Name subtext>
                                      suffix_op: (Slice begin:(ArithWord w:{(Lit_Digits 1)}))
                                      spids: [1892 1896]
                                    )
                                  )
                                } {($ VSub_Name '$PARSER_STRING_REGEX')}
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1886 1900]
                      )
                    }
                  spids: [1885]
                )
              ]
              spids: [1885]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobNEqual
                              left: {($ VSub_QMark '$?')}
                              right: {(0)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})]
                  spids: [16777215 1916]
                )
              ]
              spids: [16777215 1924]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [(assign_pair lhs:(LhsName name:endIndex) op:Equal spids:[1935])]
              spids: [1933]
            )
            (DParen
              child: 
                (BinaryAssign
                  op_id: Arith_Equal
                  left: (LhsName name:endIndex)
                  right: 
                    (ArithBinary
                      op_id: Arith_Plus
                      left: (ArithWord w:{(Lit_Digits 1)})
                      right: 
                        (ArithWord
                          w: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [(C {(expr)} {(length)} {(DQ (${ VSub_Name value))})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [1948 1958]
                              )
                            }
                        )
                    )
                )
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobNEqual
                              left: 
                                {
                                  (DQ 
                                    (BracedVarSub
                                      token: <VSub_Name subtext>
                                      suffix_op: 
                                        (Slice
                                          begin: (ArithWord w:{(${ VSub_Name endIndex)})
                                          length: (ArithWord w:{(Lit_Digits 1)})
                                        )
                                      spids: [1969 1977]
                                    )
                                  )
                                }
                              right: {(DQ (EscapedLiteralPart token:<Lit_EscapedChar '\\"'>))}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})]
                  spids: [16777215 1989]
                )
              ]
              spids: [16777215 1997]
            )
            (C {(variable) (Lit_Other ':') (Lit_Other ':') (new)} {(String)} {(DQ (${ VSub_Name value))})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:PARSER_PARSED)
                  op: Equal
                  rhs: {(DQ (${ VSub_Name RESULT))}
                  spids: [2015]
                )
              ]
              spids: [2015]
            )
            (DParen
              child: 
                (BinaryAssign
                  op_id: Arith_Equal
                  left: (LhsName name:PARSER_PARSED_COUNT)
                  right: 
                    (ArithBinary
                      op_id: Arith_Plus
                      left: 
                        (ArithWord
                          w: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [(C {(expr)} {(length)} {(DQ (${ VSub_Name value))})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [2029 2039]
                              )
                            }
                        )
                      right: (ArithWord w:{(Lit_Digits 2)})
                    )
                )
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
          ]
          spids: [1737]
        )
      spids: [1725 1736]
    )
    (FuncDef
      name: 'parser::parse::sexp'
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(${ VSub_Name PARSER_DEBUG)}
                              right: {(1)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Sentence
                      child: (C {(stderr)} {(DQ (${ VSub_Name FUNCNAME) (' ') (${ VSub_At '@'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  spids: [16777215 2096]
                )
              ]
              spids: [16777215 2112]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:text)
                  op: Equal
                  rhs: {(DQ (${ VSub_Number 1))}
                  spids: [2118]
                )
              ]
              spids: [2116]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:originalOffset)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (BracedVarSub
                          token: <VSub_Number 2>
                          suffix_op: (StringUnary op_id:VTest_Hyphen arg_word:{(0)})
                          spids: [2130 2134]
                        )
                      )
                    }
                  spids: [2128]
                )
              ]
              spids: [2126]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:offset)
                  op: Equal
                  rhs: {($ VSub_Name '$originalOffset')}
                  spids: [2140]
                )
              ]
              spids: [2138]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(${ VSub_Name PARSER_DEBUG)}
                              right: {(1)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Sentence
                      child: 
                        (C {(stderr)} 
                          {
                            (DQ ('Trying to parse sexp from:\n') 
                              (BracedVarSub
                                token: <VSub_Name text>
                                suffix_op: (Slice begin:(ArithWord w:{(${ VSub_Name offset)}))
                                spids: [2166 2172]
                              )
                            )
                          }
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  spids: [16777215 2160]
                )
              ]
              spids: [16777215 2177]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobNEqual
                              left: 
                                {
                                  (DQ 
                                    (BracedVarSub
                                      token: <VSub_Name text>
                                      suffix_op: 
                                        (Slice
                                          begin: (ArithWord w:{(${ VSub_Name offset)})
                                          length: (ArithWord w:{(Lit_Digits 1)})
                                        )
                                      spids: [2186 2194]
                                    )
                                  )
                                }
                              right: {(DQ ('('))}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:PARSER_PARSED)
                          op: Equal
                          rhs: {(DQ )}
                          spids: [2209]
                        )
                      ]
                      spids: [2209]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:PARSER_PARSED_COUNT)
                          op: Equal
                          rhs: {(0)}
                          spids: [2214]
                        )
                      ]
                      spids: [2214]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
                  ]
                  spids: [16777215 2206]
                )
              ]
              spids: [16777215 2223]
            )
            (DParen
              child: 
                (BinaryAssign
                  op_id: Arith_PlusEqual
                  left: (LhsName name:offset)
                  right: (ArithWord w:{(Lit_Digits 1)})
                )
            )
            (Sentence
              child: 
                (C 
                  {(variable) (Lit_Other ':') (Lit_Other ':') (LinkedList) (Lit_Other ':') 
                    (Lit_Other ':') (new)
                  }
                )
              terminator: <Op_Semi ';'>
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:items)
                  op: Equal
                  rhs: {(DQ (${ VSub_Name RESULT))}
                  spids: [2284]
                )
              ]
              spids: [2282]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C 
                          {(parser) (Lit_Other ':') (Lit_Other ':') (parse) (Lit_Other ':') 
                            (Lit_Other ':') (whitespace)
                          } {(DQ ($ VSub_Name '$text'))} {(${ VSub_Name offset)}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (DParen
                      child: 
                        (BinaryAssign
                          op_id: Arith_PlusEqual
                          left: (LhsName name:offset)
                          right: (ArithWord w:{(${ VSub_Name PARSER_PARSED_COUNT)})
                        )
                    )
                  ]
                  spids: [16777215 2316]
                )
              ]
              spids: [16777215 2333]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: 
                                {
                                  (DQ 
                                    (BracedVarSub
                                      token: <VSub_Name text>
                                      suffix_op: 
                                        (Slice
                                          begin: (ArithWord w:{(${ VSub_Name offset)})
                                          length: (ArithWord w:{(Lit_Digits 1)})
                                        )
                                      spids: [2346 2354]
                                    )
                                  )
                                }
                              right: {(DQ (')'))}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (DParen
                      child: 
                        (BinaryAssign
                          op_id: Arith_PlusEqual
                          left: (LhsName name:offset)
                          right: (ArithWord w:{(Lit_Digits 1)})
                        )
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:PARSER_PARSED)
                          op: Equal
                          rhs: {(${ VSub_Name items)}
                          spids: [2381]
                        )
                      ]
                      spids: [2381]
                    )
                    (DParen
                      child: 
                        (BinaryAssign
                          op_id: Arith_Equal
                          left: (LhsName name:PARSER_PARSED_COUNT)
                          right: 
                            (ArithBinary
                              op_id: Arith_Minus
                              left: (ArithVarRef name:offset)
                              right: (ArithVarRef name:originalOffset)
                            )
                        )
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [16777215 2366]
                )
              ]
              spids: [16777215 2408]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(parser) (Lit_Other ':') (Lit_Other ':') (parse)} {(DQ (${ VSub_Name text))} 
                          {(${ VSub_Name offset)}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C 
                      {(variable) (Lit_Other ':') (Lit_Other ':') (LinkedList) (Lit_Other ':') 
                        (Lit_Other ':') (append)
                      } {(DQ ($ VSub_Name '$items'))} {(${ VSub_Name PARSER_PARSED)}
                    )
                    (DParen
                      child: 
                        (BinaryAssign
                          op_id: Arith_PlusEqual
                          left: (LhsName name:offset)
                          right: (ArithWord w:{(${ VSub_Name PARSER_PARSED_COUNT)})
                        )
                    )
                  ]
                  spids: [16777215 2434]
                )
              ]
              spids: [16777215 2468]
            )
            (While
              cond: [(Sentence child:(C {(true)}) terminator:<Op_Semi ';'>)]
              body: 
                (DoGroup
                  children: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C 
                                  {(parser) (Lit_Other ':') (Lit_Other ':') (parse) (Lit_Other ':') 
                                    (Lit_Other ':') (whitespace)
                                  } {(DQ ($ VSub_Name '$text'))} {(${ VSub_Name offset)}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (DParen
                              child: 
                                (BinaryAssign
                                  op_id: Arith_PlusEqual
                                  left: (LhsName name:offset)
                                  right: (ArithWord w:{(${ VSub_Name PARSER_PARSED_COUNT)})
                                )
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DBracket
                                          expr: 
                                            (BoolBinary
                                              op_id: BoolBinary_GlobDEqual
                                              left: 
                                                {
                                                  (DQ 
                                                    (BracedVarSub
                                                      token: <VSub_Name text>
                                                      suffix_op: 
                                                        (Slice
                                                          begin: (ArithWord w:{(${ VSub_Name offset)})
                                                          length: (ArithWord w:{(Lit_Digits 1)})
                                                        )
                                                      spids: [2540 2548]
                                                    )
                                                  )
                                                }
                                              right: {(DQ (')'))}
                                            )
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (DParen
                                      child: 
                                        (BinaryAssign
                                          op_id: Arith_PlusEqual
                                          left: (LhsName name:offset)
                                          right: (ArithWord w:{(Lit_Digits 1)})
                                        )
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:PARSER_PARSED)
                                          op: Equal
                                          rhs: {(${ VSub_Name items)}
                                          spids: [2575]
                                        )
                                      ]
                                      spids: [2575]
                                    )
                                    (DParen
                                      child: 
                                        (BinaryAssign
                                          op_id: Arith_Equal
                                          left: (LhsName name:PARSER_PARSED_COUNT)
                                          right: 
                                            (ArithBinary
                                              op_id: Arith_Minus
                                              left: (ArithVarRef name:offset)
                                              right: (ArithVarRef name:originalOffset)
                                            )
                                        )
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Return return>
                                      arg_word: {(0)}
                                    )
                                  ]
                                  spids: [16777215 2560]
                                )
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(parser) (Lit_Other ':') (Lit_Other ':') (parse)} 
                                          {(DQ (${ VSub_Name text))} {(${ VSub_Name offset)}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C 
                                      {(variable) (Lit_Other ':') (Lit_Other ':') (LinkedList) 
                                        (Lit_Other ':') (Lit_Other ':') (append)
                                      } {(DQ ($ VSub_Name '$items'))} {(DQ (${ VSub_Name PARSER_PARSED))}
                                    )
                                    (DParen
                                      child: 
                                        (BinaryAssign
                                          op_id: Arith_PlusEqual
                                          left: (LhsName name:offset)
                                          right: (ArithWord w:{(${ VSub_Name PARSER_PARSED_COUNT)})
                                        )
                                    )
                                  ]
                                  spids: [2602 2620]
                                )
                              ]
                              else_action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:PARSER_PARSED)
                                      op: Equal
                                      rhs: {(DQ )}
                                      spids: [2659]
                                    )
                                  ]
                                  spids: [2659]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:PARSER_PARSED_COUNT)
                                      op: Equal
                                      rhs: {(0)}
                                      spids: [2664]
                                    )
                                  ]
                                  spids: [2664]
                                )
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {(1)}
                                )
                              ]
                              spids: [2656 2673]
                            )
                          ]
                          spids: [16777215 2515]
                        )
                      ]
                      else_action: [
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (DBracket
                                      expr: 
                                        (BoolBinary
                                          op_id: BoolBinary_GlobDEqual
                                          left: 
                                            {
                                              (DQ 
                                                (BracedVarSub
                                                  token: <VSub_Name text>
                                                  suffix_op: 
                                                    (Slice
                                                      begin: (ArithWord w:{(${ VSub_Name offset)})
                                                      length: (ArithWord w:{(Lit_Digits 1)})
                                                    )
                                                  spids: [2688 2696]
                                                )
                                              )
                                            }
                                          right: {(DQ (')'))}
                                        )
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (DParen
                                  child: 
                                    (BinaryAssign
                                      op_id: Arith_PlusEqual
                                      left: (LhsName name:offset)
                                      right: (ArithWord w:{(Lit_Digits 1)})
                                    )
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:PARSER_PARSED)
                                      op: Equal
                                      rhs: {(${ VSub_Name items)}
                                      spids: [2723]
                                    )
                                  ]
                                  spids: [2723]
                                )
                                (DParen
                                  child: 
                                    (BinaryAssign
                                      op_id: Arith_Equal
                                      left: (LhsName name:PARSER_PARSED_COUNT)
                                      right: 
                                        (ArithBinary
                                          op_id: Arith_Minus
                                          left: (ArithVarRef name:offset)
                                          right: (ArithVarRef name:originalOffset)
                                        )
                                    )
                                )
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [16777215 2708]
                            )
                          ]
                          else_action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:PARSER_PARSED)
                                  op: Equal
                                  rhs: {(DQ )}
                                  spids: [2754]
                                )
                              ]
                              spids: [2754]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:PARSER_PARSED_COUNT)
                                  op: Equal
                                  rhs: {(0)}
                                  spids: [2759]
                                )
                              ]
                              spids: [2759]
                            )
                            (ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(1)}
                            )
                          ]
                          spids: [2750 2768]
                        )
                      ]
                      spids: [2677 2771]
                    )
                  ]
                  spids: [2493 2774]
                )
            )
            (C {(stderr)} {(DQ ('Should never get here'))})
            (ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
          ]
          spids: [2078]
        )
      spids: [2066 2077]
    )
    (Assignment
      keyword: Assign_Declare
      flags: [-g]
      pairs: [
        (assign_pair
          lhs: (LhsName name:PARSER_WHITESPACE_REGEX)
          op: Equal
          rhs: {(SQ <'\\([ \t\n'> <'][ \t\n'> <']*\\)'>)}
          spids: [2805]
        )
      ]
      spids: [2801]
    )
    (FuncDef
      name: 'parser::parse::whitespace'
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(${ VSub_Name PARSER_DEBUG)}
                              right: {(1)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Sentence
                      child: (C {(stderr)} {(DQ (${ VSub_Name FUNCNAME) (' ') (${ VSub_At '@'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  spids: [16777215 2842]
                )
              ]
              spids: [16777215 2858]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:text)
                  op: Equal
                  rhs: {(DQ (${ VSub_Number 1))}
                  spids: [2864]
                )
              ]
              spids: [2862]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:originalOffset)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (BracedVarSub
                          token: <VSub_Number 2>
                          suffix_op: (StringUnary op_id:VTest_Hyphen arg_word:{(0)})
                          spids: [2876 2880]
                        )
                      )
                    }
                  spids: [2874]
                )
              ]
              spids: [2872]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {(${ VSub_Name PARSER_DEBUG)}
                              right: {(1)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Sentence
                      child: 
                        (C {(stderr)} 
                          {
                            (DQ ('Trying to parse whitespace from:\n') 
                              (BracedVarSub
                                token: <VSub_Name text>
                                suffix_op: (Slice begin:(ArithWord w:{(${ VSub_Name originalOffset)}))
                                spids: [2906 2912]
                              )
                            )
                          }
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  spids: [16777215 2900]
                )
              ]
              spids: [16777215 2917]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:offset)
                  op: Equal
                  rhs: {(${ VSub_Name originalOffset)}
                  spids: [2923]
                )
              ]
              spids: [2921]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [
                (assign_pair
                  lhs: (LhsName name:char)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (BracedVarSub
                          token: <VSub_Name text>
                          suffix_op: 
                            (Slice
                              begin: (ArithWord w:{(${ VSub_Name offset)})
                              length: (ArithWord w:{(Lit_Digits 1)})
                            )
                          spids: [2933 2941]
                        )
                      )
                    }
                  spids: [2931]
                )
              ]
              spids: [2929]
            )
            (Assignment
              keyword: Assign_Declare
              pairs: [(assign_pair lhs:(LhsName name:parsed) op:Equal rhs:{(DQ )} spids:[2947])]
              spids: [2945]
            )
            (While
              cond: [
                (Sentence
                  child: 
                    (DBracket
                      expr: 
                        (LogicalOr
                          left: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {($ VSub_Name '$char')}
                              right: {(DQ (' '))}
                            )
                          right: 
                            (LogicalOr
                              left: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {($ VSub_Name '$char')}
                                  right: {(DQ ('\t'))}
                                )
                              right: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {($ VSub_Name '$char')}
                                  right: {(DQ ('\n'))}
                                )
                            )
                        )
                    )
                  terminator: <Op_Semi ';'>
                )
              ]
              body: 
                (DoGroup
                  children: [
                    (DParen
                      child: 
                        (BinaryAssign
                          op_id: Arith_PlusEqual
                          left: (LhsName name:offset)
                          right: (ArithWord w:{(Lit_Digits 1)})
                        )
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:parsed)
                          op: PlusEqual
                          rhs: {(DQ (${ VSub_Name char))}
                          spids: [3003]
                        )
                      ]
                      spids: [3003]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:char)
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (BracedVarSub
                                  token: <VSub_Name text>
                                  suffix_op: 
                                    (Slice
                                      begin: (ArithWord w:{(${ VSub_Name offset)})
                                      length: (ArithWord w:{(Lit_Digits 1)})
                                    )
                                  spids: [3013 3021]
                                )
                              )
                            }
                          spids: [3011]
                        )
                      ]
                      spids: [3011]
                    )
                  ]
                  spids: [2988 3025]
                )
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_gt
                              left: {($ VSub_Name '$offset')}
                              right: {($ VSub_Name '$originalOffset')}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:PARSER_PARSED)
                          op: Equal
                          rhs: {(DQ (${ VSub_Name parsed))}
                          spids: [3045]
                        )
                      ]
                      spids: [3045]
                    )
                    (DParen
                      child: 
                        (BinaryAssign
                          op_id: Arith_Equal
                          left: (LhsName name:PARSER_PARSED_COUNT)
                          right: 
                            (ArithBinary
                              op_id: Arith_Minus
                              left: (ArithVarRef name:offset)
                              right: (ArithVarRef name:originalOffset)
                            )
                        )
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [16777215 3042]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:PARSER_PARSED)
                      op: Equal
                      rhs: {(DQ )}
                      spids: [3077]
                    )
                  ]
                  spids: [3077]
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:PARSER_PARSED_COUNT)
                      op: Equal
                      rhs: {(0)}
                      spids: [3082]
                    )
                  ]
                  spids: [3082]
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              spids: [3074 3091]
            )
          ]
          spids: [2824]
        )
      spids: [2812 2823]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (C {(Lit_Other '[')} {($ VSub_Number '$0')} {(KW_Bang '!') (Lit_Other '=')} 
                  {($ VSub_Name '$BASH_SOURCE')} {(Lit_Other ']')}
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [(ControlFlow token:<ControlFlow_Return return>)]
          spids: [16777215 3117]
        )
      ]
      spids: [16777215 3122]
    )
    (C {(.)} 
      {
        (BracedVarSub
          token: <VSub_Name BASH_SOURCE>
          suffix_op: (StringUnary op_id:VOp1_Percent arg_word:{(Lit_Slash /) ('*')})
          spids: [3127 3132]
        ) (/test.sh)
      }
    )
    (Sentence
      child: (C {(parser) (Lit_Other ':') (Lit_Other ':') (parse)} {(DQ (1))})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(0)} {($ VSub_QMark '$?')} 
      {(DQ ('parse 1 succeeds'))}
    )
    (Sentence
      child: (C {(variable) (Lit_Other ':') (Lit_Other ':') (debug)} {(DQ (${ VSub_Name RESULT))})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(DQ ('Integer :: 1'))} 
      {(DQ (${ VSub_Name RESULT))} {(DQ ('parse 1'))}
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(1)} 
      {(DQ (${ VSub_Name PARSER_PARSED_COUNT))} {(DQ ('parse 1 / count'))}
    )
    (Sentence
      child: (C {(parser) (Lit_Other ':') (Lit_Other ':') (parse)} {(DQ (123456))})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(0)} {($ VSub_QMark '$?')} 
      {(DQ ('parse 123456 succeeds'))}
    )
    (Sentence
      child: (C {(variable) (Lit_Other ':') (Lit_Other ':') (debug)} {(DQ (${ VSub_Name RESULT))})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(DQ ('Integer :: 123456'))} 
      {(DQ (${ VSub_Name RESULT))} {(DQ ('parse 123456'))}
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(6)} 
      {(DQ (${ VSub_Name PARSER_PARSED_COUNT))} {(DQ ('parse 123456 / count'))}
    )
    (Sentence
      child: (C {(parser) (Lit_Other ':') (Lit_Other ':') (parse)} {(DQ (0))})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(0)} {($ VSub_QMark '$?')} 
      {(DQ ('parse 0 succeeds'))}
    )
    (Sentence
      child: (C {(variable) (Lit_Other ':') (Lit_Other ':') (debug)} {(DQ (${ VSub_Name RESULT))})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(DQ ('Integer :: 0'))} 
      {(DQ (${ VSub_Name RESULT))} {(DQ ('parse 0'))}
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(1)} 
      {(DQ (${ VSub_Name PARSER_PARSED_COUNT))} {(DQ ('parse 0 / count'))}
    )
    (Sentence
      child: (C {(parser) (Lit_Other ':') (Lit_Other ':') (parse)} {(DQ (-10))})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(0)} {($ VSub_QMark '$?')} 
      {(DQ ('parse -10 succeeds'))}
    )
    (Sentence
      child: (C {(variable) (Lit_Other ':') (Lit_Other ':') (debug)} {(DQ (${ VSub_Name RESULT))})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(DQ ('Integer :: -10'))} 
      {(DQ (${ VSub_Name RESULT))} {(DQ ('parse -10'))}
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(3)} 
      {(DQ (${ VSub_Name PARSER_PARSED_COUNT))} {(DQ ('parse 1 / count'))}
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:output)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [(C {(parser) (Lit_Other ':') (Lit_Other ':') (parse)} {(DQ (-0))})]
                  )
                left_token: <Left_CommandSub '$('>
                spids: [3458 3467]
              )
            }
          spids: [3457]
        )
      ]
      spids: [3457]
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(1)} {($ VSub_QMark '$?')} 
      {(DQ ('parse -0 should fail'))}
    )
    (Sentence
      child: (C {(parser) (Lit_Other ':') (Lit_Other ':') (parse)} {(DQ (v))})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(0)} {($ VSub_QMark '$?')} 
      {
        (DQ ('parse ') (EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) (abc) 
          (EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) (' succeeds')
        )
      }
    )
    (Sentence
      child: (C {(variable) (Lit_Other ':') (Lit_Other ':') (debug)} {(DQ (${ VSub_Name RESULT))})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(DQ ('Identifier :: v'))} 
      {(DQ (${ VSub_Name RESULT))} {(DQ ('parse v'))}
    )
    (Sentence
      child: (C {(parser) (Lit_Other ':') (Lit_Other ':') (parse)} {(DQ ('a?'))})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(0)} {($ VSub_QMark '$?')} 
      {
        (DQ ('parse ') (EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) (abc) 
          (EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) (' succeeds')
        )
      }
    )
    (Sentence
      child: (C {(variable) (Lit_Other ':') (Lit_Other ':') (debug)} {(DQ (${ VSub_Name RESULT))})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(DQ ('Identifier :: a?'))} 
      {(DQ (${ VSub_Name RESULT))} {(DQ ('parse a?'))}
    )
    (Sentence
      child: (C {(parser) (Lit_Other ':') (Lit_Other ':') (parse)} {(SQ <'"abc"'>)})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(0)} {($ VSub_QMark '$?')} 
      {
        (DQ ('parse ') (EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) (abc) 
          (EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) (' succeeds')
        )
      }
    )
    (Sentence
      child: (C {(variable) (Lit_Other ':') (Lit_Other ':') (debug)} {(DQ (${ VSub_Name RESULT))})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(DQ ('String :: abc'))} 
      {(DQ (${ VSub_Name RESULT))} 
      {
        (DQ ('parse ') (EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) (abc) 
          (EscapedLiteralPart token:<Lit_EscapedChar '\\"'>)
        )
      }
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(5)} 
      {(DQ (${ VSub_Name PARSER_PARSED_COUNT))} 
      {
        (DQ ('parse ') (EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) (abc) 
          (EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) (' / count')
        )
      }
    )
    (Sentence
      child: 
        (C 
          {(parser) (Lit_Other ':') (Lit_Other ':') (parse) (Lit_Other ':') (Lit_Other ':') (whitespace)} {(SQ <' \t '>)}
        )
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(0)} {($ VSub_QMark '$?')} 
      {(DQ ('match whitespace / code'))}
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(3)} {(${ VSub_Name PARSER_PARSED_COUNT)} 
      {(DQ ('match whitepace / count'))}
    )
    (Sentence
      child: 
        (C 
          {(parser) (Lit_Other ':') (Lit_Other ':') (parse) (Lit_Other ':') (Lit_Other ':') (whitespace)} {(SQ <'abc def'>)}
        )
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(1)} {($ VSub_QMark '$?')} 
      {(DQ ('match non-whitespace / code'))}
    )
    (Sentence
      child: 
        (C 
          {(parser) (Lit_Other ':') (Lit_Other ':') (parse) (Lit_Other ':') (Lit_Other ':') (whitespace)} {(SQ )}
        )
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(1)} {($ VSub_QMark '$?')} 
      {(DQ ('match empty non-whitespace / code'))}
    )
    (Sentence
      child: 
        (C 
          {(parser) (Lit_Other ':') (Lit_Other ':') (parse) (Lit_Other ':') (Lit_Other ':') (whitespace)} {(SQ <')'>)}
        )
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(1)} {($ VSub_QMark '$?')} 
      {(DQ ('match close paren against whitespace / code'))}
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:TEST)
          op: Equal
          rhs: {(DQ ('multiExpression - single expr'))}
          spids: [3872]
        )
      ]
      spids: [3872]
    )
    (Sentence
      child: 
        (C 
          {(parser) (Lit_Other ':') (Lit_Other ':') (parse) (Lit_Other ':') (Lit_Other ':') 
            (multiExpression)
          } {(DQ (a))}
        )
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(0)} {($ VSub_QMark '$?')} 
      {(DQ (${ VSub_Name TEST) (' / code'))}
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(1)} {(${ VSub_Name PARSER_PARSED_COUNT)} 
      {(DQ (${ VSub_Name TEST) (' / count'))}
    )
    (Sentence
      child: (C {(variable) (Lit_Other ':') (Lit_Other ':') (type)} {(${ VSub_Name PARSER_PARSED)})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(DQ (LinkedList))} {(${ VSub_Name RESULT)} 
      {(DQ (${ VSub_Name TEST) (' / type'))}
    )
    (Sentence
      child: 
        (C 
          {(variable) (Lit_Other ':') (Lit_Other ':') (LinkedList) (Lit_Other ':') (Lit_Other ':') 
            (length)
          } {(${ VSub_Name PARSER_PARSED)}
        )
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(1)} {(${ VSub_Name RESULT)} 
      {(DQ (${ VSub_Name TEST) (' / length'))}
    )
    (Sentence
      child: 
        (C 
          {(variable) (Lit_Other ':') (Lit_Other ':') (LinkedList) (Lit_Other ':') (Lit_Other ':') 
            (first)
          } {(${ VSub_Name PARSER_PARSED)}
        )
      terminator: <Op_Semi ';'>
    )
    (Sentence
      child: (C {(variable) (Lit_Other ':') (Lit_Other ':') (value)} {(${ VSub_Name RESULT)})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(DQ (a))} {(DQ (${ VSub_Name RESULT))} 
      {(DQ (${ VSub_Name TEST) (' / value'))}
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:TEST)
          op: Equal
          rhs: {(DQ ('multiExpression - multiple expressions'))}
          spids: [4040]
        )
      ]
      spids: [4040]
    )
    (Sentence
      child: 
        (C 
          {(parser) (Lit_Other ':') (Lit_Other ':') (parse) (Lit_Other ':') (Lit_Other ':') 
            (multiExpression)
          } {(DQ ('a b'))}
        )
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(0)} {($ VSub_QMark '$?')} 
      {(DQ (${ VSub_Name TEST) (' / code'))}
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(3)} {(${ VSub_Name PARSER_PARSED_COUNT)} 
      {(DQ (${ VSub_Name TEST) (' / count'))}
    )
    (Sentence
      child: (C {(variable) (Lit_Other ':') (Lit_Other ':') (type)} {(${ VSub_Name PARSER_PARSED)})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(DQ (LinkedList))} {(${ VSub_Name RESULT)} 
      {(DQ (${ VSub_Name TEST) (' / type'))}
    )
    (Sentence
      child: 
        (C 
          {(variable) (Lit_Other ':') (Lit_Other ':') (LinkedList) (Lit_Other ':') (Lit_Other ':') 
            (length)
          } {(${ VSub_Name PARSER_PARSED)}
        )
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(2)} {(${ VSub_Name RESULT)} 
      {(DQ (${ VSub_Name TEST) (' / length'))}
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:TEST)
          op: Equal
          rhs: {(DQ ('multiExpression - whitespaces'))}
          spids: [4157]
        )
      ]
      spids: [4157]
    )
    (Sentence
      child: 
        (C 
          {(parser) (Lit_Other ':') (Lit_Other ':') (parse) (Lit_Other ':') (Lit_Other ':') 
            (multiExpression)
          } {(DQ (' b '))}
        )
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(0)} {($ VSub_QMark '$?')} 
      {(DQ (${ VSub_Name TEST) (' / code'))}
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(3)} {(${ VSub_Name PARSER_PARSED_COUNT)} 
      {(DQ (${ VSub_Name TEST) (' / count'))}
    )
    (Sentence
      child: (C {(variable) (Lit_Other ':') (Lit_Other ':') (type)} {(${ VSub_Name PARSER_PARSED)})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(DQ (LinkedList))} {(${ VSub_Name RESULT)} 
      {(DQ (${ VSub_Name TEST) (' / type'))}
    )
    (Sentence
      child: 
        (C 
          {(variable) (Lit_Other ':') (Lit_Other ':') (LinkedList) (Lit_Other ':') (Lit_Other ':') 
            (length)
          } {(${ VSub_Name PARSER_PARSED)}
        )
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(1)} {(${ VSub_Name RESULT)} 
      {(DQ (${ VSub_Name TEST) (' / length'))}
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:TEST)
          op: Equal
          rhs: {(DQ ('multiExpression - integer'))}
          spids: [4274]
        )
      ]
      spids: [4274]
    )
    (Sentence
      child: 
        (C 
          {(parser) (Lit_Other ':') (Lit_Other ':') (parse) (Lit_Other ':') (Lit_Other ':') 
            (multiExpression)
          } {(DQ (1))}
        )
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(0)} {($ VSub_QMark '$?')} 
      {(DQ (${ VSub_Name TEST) (' / code'))}
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(1)} {(${ VSub_Name PARSER_PARSED_COUNT)} 
      {(DQ (${ VSub_Name TEST) (' / count'))}
    )
    (Sentence
      child: (C {(variable) (Lit_Other ':') (Lit_Other ':') (type)} {(${ VSub_Name PARSER_PARSED)})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(DQ (LinkedList))} {(${ VSub_Name RESULT)} 
      {(DQ (${ VSub_Name TEST) (' / type'))}
    )
    (Sentence
      child: 
        (C 
          {(variable) (Lit_Other ':') (Lit_Other ':') (LinkedList) (Lit_Other ':') (Lit_Other ':') 
            (length)
          } {(${ VSub_Name PARSER_PARSED)}
        )
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(1)} {(${ VSub_Name RESULT)} 
      {(DQ (${ VSub_Name TEST) (' / length'))}
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:TEST)
          op: Equal
          rhs: {(DQ ('multiExpression - sexp'))}
          spids: [4391]
        )
      ]
      spids: [4391]
    )
    (Sentence
      child: 
        (C 
          {(parser) (Lit_Other ':') (Lit_Other ':') (parse) (Lit_Other ':') (Lit_Other ':') 
            (multiExpression)
          } {(DQ ('(a)'))}
        )
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(0)} {($ VSub_QMark '$?')} 
      {(DQ (${ VSub_Name TEST) (' / code'))}
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(3)} {(${ VSub_Name PARSER_PARSED_COUNT)} 
      {(DQ (${ VSub_Name TEST) (' / count'))}
    )
    (Sentence
      child: (C {(variable) (Lit_Other ':') (Lit_Other ':') (type)} {(${ VSub_Name PARSER_PARSED)})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(DQ (LinkedList))} {(${ VSub_Name RESULT)} 
      {(DQ (${ VSub_Name TEST) (' / type'))}
    )
    (Sentence
      child: 
        (C 
          {(variable) (Lit_Other ':') (Lit_Other ':') (LinkedList) (Lit_Other ':') (Lit_Other ':') 
            (length)
          } {(${ VSub_Name PARSER_PARSED)}
        )
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(1)} {(${ VSub_Name RESULT)} 
      {(DQ (${ VSub_Name TEST) (' / length'))}
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:TEST)
          op: Equal
          rhs: {(DQ ('multiExpression - sexps'))}
          spids: [4508]
        )
      ]
      spids: [4508]
    )
    (Sentence
      child: 
        (C 
          {(parser) (Lit_Other ':') (Lit_Other ':') (parse) (Lit_Other ':') (Lit_Other ':') 
            (multiExpression)
          } {(DQ ('(a) (b)'))}
        )
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(0)} {($ VSub_QMark '$?')} 
      {(DQ (${ VSub_Name TEST) (' / code'))}
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(7)} {(${ VSub_Name PARSER_PARSED_COUNT)} 
      {(DQ (${ VSub_Name TEST) (' / count'))}
    )
    (Sentence
      child: (C {(variable) (Lit_Other ':') (Lit_Other ':') (type)} {(${ VSub_Name PARSER_PARSED)})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(DQ (LinkedList))} {(${ VSub_Name RESULT)} 
      {(DQ (${ VSub_Name TEST) (' / type'))}
    )
    (Sentence
      child: 
        (C 
          {(variable) (Lit_Other ':') (Lit_Other ':') (LinkedList) (Lit_Other ':') (Lit_Other ':') 
            (length)
          } {(${ VSub_Name PARSER_PARSED)}
        )
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(2)} {(${ VSub_Name RESULT)} 
      {(DQ (${ VSub_Name TEST) (' / length'))}
    )
    (Sentence
      child: (C {(parser) (Lit_Other ':') (Lit_Other ':') (parse)} {(DQ ('()'))})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(0)} {($ VSub_QMark '$?')} 
      {(DQ ('match empty sexp / code'))}
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(2)} {(${ VSub_Name PARSER_PARSED_COUNT)} 
      {(DQ ('match empty sexp / count'))}
    )
    (Sentence
      child: (C {(variable) (Lit_Other ':') (Lit_Other ':') (type)} {(${ VSub_Name PARSER_PARSED)})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(DQ (LinkedList))} {(${ VSub_Name RESULT)} 
      {(DQ ('match empty sexp / type'))}
    )
    (Sentence
      child: 
        (C 
          {(variable) (Lit_Other ':') (Lit_Other ':') (LinkedList) (Lit_Other ':') (Lit_Other ':') 
            (length)
          } {(${ VSub_Name PARSER_PARSED)}
        )
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(0)} {(${ VSub_Name RESULT)} 
      {(DQ ('match empty sexp / length'))}
    )
    (Sentence
      child: (C {(parser) (Lit_Other ':') (Lit_Other ':') (parse)} {(DQ ('( )'))})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(0)} {($ VSub_QMark '$?')} 
      {(DQ ('match almost empty sexp / code'))}
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(3)} {(${ VSub_Name PARSER_PARSED_COUNT)} 
      {(DQ ('match almost empty sexp / count'))}
    )
    (Sentence
      child: (C {(variable) (Lit_Other ':') (Lit_Other ':') (type)} {(${ VSub_Name PARSER_PARSED)})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(DQ (LinkedList))} {(${ VSub_Name RESULT)} 
      {(DQ ('match almost empty sexp / type'))}
    )
    (Sentence
      child: 
        (C 
          {(variable) (Lit_Other ':') (Lit_Other ':') (LinkedList) (Lit_Other ':') (Lit_Other ':') 
            (length)
          } {(${ VSub_Name PARSER_PARSED)}
        )
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(0)} {(${ VSub_Name RESULT)} 
      {(DQ ('match almost empty sexp / length'))}
    )
    (Sentence
      child: (C {(parser) (Lit_Other ':') (Lit_Other ':') (parse)} {(DQ ('(a)'))})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(0)} {($ VSub_QMark '$?')} 
      {(DQ ('single element sexp / code'))}
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(3)} {(${ VSub_Name PARSER_PARSED_COUNT)} 
      {(DQ ('single element sexp / count'))}
    )
    (Sentence
      child: (C {(variable) (Lit_Other ':') (Lit_Other ':') (type)} {(${ VSub_Name PARSER_PARSED)})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(DQ (LinkedList))} {(${ VSub_Name RESULT)} 
      {(DQ ('single element sexp / type'))}
    )
    (Sentence
      child: 
        (C 
          {(variable) (Lit_Other ':') (Lit_Other ':') (LinkedList) (Lit_Other ':') (Lit_Other ':') 
            (length)
          } {(${ VSub_Name PARSER_PARSED)}
        )
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(1)} {(${ VSub_Name RESULT)} 
      {(DQ ('single element sexp / length'))}
    )
    (Sentence
      child: (C {(parser) (Lit_Other ':') (Lit_Other ':') (parse)} {(DQ ('( a )'))})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(0)} {($ VSub_QMark '$?')} 
      {(DQ ('single element sexp / code'))}
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(5)} {(${ VSub_Name PARSER_PARSED_COUNT)} 
      {(DQ ('single element sexp / count'))}
    )
    (Sentence
      child: (C {(variable) (Lit_Other ':') (Lit_Other ':') (type)} {(${ VSub_Name PARSER_PARSED)})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(DQ (LinkedList))} {(${ VSub_Name RESULT)} 
      {(DQ ('single element sexp / type'))}
    )
    (Sentence
      child: 
        (C 
          {(variable) (Lit_Other ':') (Lit_Other ':') (LinkedList) (Lit_Other ':') (Lit_Other ':') 
            (length)
          } {(${ VSub_Name PARSER_PARSED)}
        )
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(1)} {(${ VSub_Name RESULT)} 
      {(DQ ('single element sexp / length'))}
    )
    (Sentence
      child: (C {(parser) (Lit_Other ':') (Lit_Other ':') (parse)} {(DQ ('(a b)'))})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(0)} {($ VSub_QMark '$?')} 
      {(DQ ('two element sexp / code'))}
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(5)} {(${ VSub_Name PARSER_PARSED_COUNT)} 
      {(DQ ('two element sexp / count'))}
    )
    (Sentence
      child: (C {(variable) (Lit_Other ':') (Lit_Other ':') (type)} {(${ VSub_Name PARSER_PARSED)})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(DQ (LinkedList))} {(${ VSub_Name RESULT)} 
      {(DQ ('two element sexp / type'))}
    )
    (Sentence
      child: 
        (C 
          {(variable) (Lit_Other ':') (Lit_Other ':') (LinkedList) (Lit_Other ':') (Lit_Other ':') 
            (length)
          } {(${ VSub_Name PARSER_PARSED)}
        )
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(2)} {(${ VSub_Name RESULT)} 
      {(DQ ('two element sexp / length'))}
    )
    (Sentence
      child: (C {(parser) (Lit_Other ':') (Lit_Other ':') (parse)} {(DQ ('((a) (b) c)'))})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(0)} {($ VSub_QMark '$?')} 
      {(DQ ('nested element sexp / code'))}
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(11)} {(${ VSub_Name PARSER_PARSED_COUNT)} 
      {(DQ ('nested element sexp / count'))}
    )
    (Sentence
      child: (C {(variable) (Lit_Other ':') (Lit_Other ':') (type)} {(${ VSub_Name PARSER_PARSED)})
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(DQ (LinkedList))} {(${ VSub_Name RESULT)} 
      {(DQ ('nested element sexp / type'))}
    )
    (Sentence
      child: 
        (C 
          {(variable) (Lit_Other ':') (Lit_Other ':') (LinkedList) (Lit_Other ':') (Lit_Other ':') 
            (length)
          } {(${ VSub_Name PARSER_PARSED)}
        )
      terminator: <Op_Semi ';'>
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (equals)} {(3)} {(${ VSub_Name RESULT)} 
      {(DQ ('nested element sexp / length'))}
    )
    (C {(assert) (Lit_Other ':') (Lit_Other ':') (report)})
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (AndOr
                  ops: [Op_DAmp]
                  children: [
                    (C {(Lit_Other '[')} 
                      {
                        (BracedVarSub
                          token: <VSub_Number 1>
                          suffix_op: (StringUnary op_id:VTest_Plus arg_word:{(isset)})
                          spids: [5226 5230]
                        )
                      } {(Lit_Other ']')}
                    )
                    (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} {(Lit_Other '=') (Lit_Other '=')} 
                      {(DQ (debug))} {(Lit_Other ']')}
                    )
                  ]
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [(C {(variable) (Lit_Other ':') (Lit_Other ':') (printMetadata)})]
          spids: [16777215 5252]
        )
      ]
      spids: [16777215 5261]
    )
  ]
)