(CommandList
  children: [
    (AndOr
      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>)
      ]
      op_id: Op_DAmp
    )
    (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: [-1 151]
                )
              ]
              spids: [-1 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: [-1 215]
                )
              ]
              spids: [-1 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: [-1 313]
                )
              ]
              spids: [-1 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: [-1 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: True
                                )
                              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: [-1 467]
                        )
                      ]
                      spids: [-1 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: True
                                )
                              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: [-1 546]
                        )
                      ]
                      spids: [-1 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"))})
            (C {(exit)} {(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: [-1 674]
                )
              ]
              spids: [-1 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: [-1 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: [-1 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: [-1 866]
                )
              ]
              spids: [-1 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: [-1 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: [-1 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: [-1 1130]
                )
              ]
              spids: [-1 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: [-1 1164]
                )
              ]
              spids: [-1 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: [-1 1248]
                )
              ]
              spids: [-1 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: [-1 1320]
                )
              ]
              spids: [-1 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: [-1 1376]
                )
              ]
              spids: [-1 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: [-1 1442]
                )
              ]
              spids: [-1 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: [-1 1533]
                )
              ]
              spids: [-1 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: [-1 1605]
                )
              ]
              spids: [-1 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: [-1 1657]
                )
              ]
              spids: [-1 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: [-1 1755]
                )
              ]
              spids: [-1 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: [-1 1827]
                )
              ]
              spids: [-1 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: [-1 1867]
                )
              ]
              spids: [-1 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: [-1 1916]
                )
              ]
              spids: [-1 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: [-1 1989]
                )
              ]
              spids: [-1 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: [-1 2096]
                )
              ]
              spids: [-1 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: [-1 2160]
                )
              ]
              spids: [-1 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: [-1 2206]
                )
              ]
              spids: [-1 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: [-1 2316]
                )
              ]
              spids: [-1 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: [-1 2366]
                )
              ]
              spids: [-1 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: [-1 2434]
                )
              ]
              spids: [-1 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: [-1 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: [-1 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: [-1 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"))})
            (C {(exit)} {(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: [-1 2842]
                )
              ]
              spids: [-1 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: [-1 2900]
                )
              ]
              spids: [-1 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: [-1 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: [-1 3117]
        )
      ]
      spids: [-1 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
                  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 "]")}
                    )
                  ]
                  op_id: Op_DAmp
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [(C {(variable) (Lit_Other ":") (Lit_Other ":") (printMetadata)})]
          spids: [-1 5252]
        )
      ]
      spids: [-1 5261]
    )
  ]
)