(command.CommandList
  children: [
    (command.ShFunction
      name: usage
      body: 
        (BraceGroup
          children: [
            (C {<echo>} {(DQ ($ Id.VSub_Number '$0') <' [OPTION] FILE...'>)})
            (C {<echo>})
            (C {<echo>} {(DQ <'Options:'>)})
            (C {<echo>} {(DQ <'  -e|--eval STR    Evaluate STR'>)})
            (C {<echo>} {(DQ <'  -l|--load FILE   Load and evaluate FILE'>)})
            (C {<echo>} {(DQ <'  -r|--repl        Start a REPL'>)})
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<2>})
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_z
                              child: {(DQ ($ Id.VSub_DollarName '$BASH_VERSION'))}
                            )
                        )
                        (command.DParen
                          child: 
                            (arith_expr.Binary
                              op_id: Id.Arith_Less
                              left: 
                                {
                                  (braced_var_sub
                                    token: <Id.VSub_Name BASH_VERSINFO>
                                    bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 0>})
                                  )
                                }
                              right: {<Id.Lit_Digits 4>}
                            )
                        )
                      ]
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.Simple
              words: [{<echo>} {(DQ <'bash >= 4.0 required'>)}]
              redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
              do_fork: T
            )
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
          spids: [60 89]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:DEFAULT_IFS)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$IFS'))}
          spids: [109]
        )
      ]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:r) op:assign_op.Equal rhs:{(DQ )} spids:[119])]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:e) op:assign_op.Equal rhs:{(DQ )} spids:[123])]
    )
    (command.ShFunction
      name: error
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DPipe]
              children: [
                (command.DBracket
                  expr: (bool_expr.Unary op_id:Id.BoolUnary_z child:{(DQ ($ Id.VSub_DollarName '$e'))})
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:e)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_Number '$1'))}
                      spids: [147]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:e)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ ($ Id.VSub_Number '$1') <Id.Lit_BadBackslash '\\'> <n> 
                            ($ Id.VSub_DollarName '$e')
                          )
                        }
                      spids: [154]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:r)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$NIL')}
                  spids: [163]
                )
              ]
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<1>})
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:pb_max)
          op: assign_op.Equal
          rhs: {<100>}
          spids: [178]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:pb_newline)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                (command_sub
                  left_token: <Id.Left_DollarParen '$('>
                  child: (C {<printf>} {(SQ <'\\034'>)})
                )
              )
            }
          spids: [181]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:pb_star)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                (command_sub
                  left_token: <Id.Left_DollarParen '$('>
                  child: (C {<printf>} {(SQ <'\\035'>)})
                )
              )
            }
          spids: [192]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:pb_get)
          op: assign_op.Equal
          rhs: {(DQ <'^'> <Id.Lit_Dollar '$'>)}
          spids: [203]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:pb_unget)
          op: assign_op.Equal
          rhs: {(DQ <'^'> <Id.Lit_Dollar '$'>)}
          spids: [209]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:history_flag)
          op: assign_op.Equal
          rhs: {<1>}
          spids: [215]
        )
      ]
    )
    (command.ShFunction
      name: readline
      body: 
        (BraceGroup
          children: [
            (C {<local>} 
              {<Id.Lit_VarLike 'IFS='> 
                (single_quoted
                  left: <Id.Left_DollarSingleQuote '$\''>
                  tokens: [<Id.Char_OneChar '\\n'> <Id.Char_OneChar '\\b'>]
                  multiline: F
                )
              } {<Id.Lit_VarLike 'prompt='> (DQ <'> '>)} {<line>}
            )
            (C {<set>} {<-f>})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<read>} {<-e>} {<-r>} {<-p>} {(DQ ($ Id.VSub_DollarName '$prompt'))} {<line>})
                (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<0>})
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:pb_get)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (braced_var_sub
                          token: <Id.VSub_Name pb_get>
                          suffix_op: 
                            (suffix_op.Slice
                              begin: {<Id.Lit_Digits 0>}
                              length: 
                                {
                                  (word_part.ArithSub
                                    anode: 
                                      (arith_expr.Binary
                                        op_id: Id.Arith_Minus
                                        left: 
                                          {
                                            (braced_var_sub
                                              token: <Id.VSub_Name pb_get>
                                              prefix_op: (Id.VSub_Pound)
                                            )
                                          }
                                        right: {<Id.Lit_Digits 1>}
                                      )
                                  )
                                }
                            )
                        ) (${ Id.VSub_Name line) (${ Id.VSub_Name pb_newline) <Id.Lit_Dollar '$'>
                      )
                    }
                  spids: [268]
                )
              ]
            )
            (C {<set>} {<Id.Lit_Other '+'> <f>})
            (C {<unset>} {<IFS>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_EqualTilde
                                  left: {(DQ ($ Id.VSub_DollarName '$line'))}
                                  right: 
                                    {<Id.Lit_Other '^'> <Id.Lit_Other '['> <Id.Lit_Other '['> 
                                      <Id.Lit_Other ':'> <space> <Id.Lit_Other ':'> <Id.Lit_Other ']'> <Id.Lit_Other ']'> <Id.Lit_Other '*'> <->
                                    }
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Simple
                      words: [
                        {<echo>}
                        {(DQ <'warning: lines starting with - aren\'t stored in history'>)}
                      ]
                      redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                      do_fork: T
                    )
                  ]
                  spids: [306 330]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_n
                                  child: {(DQ ($ Id.VSub_DollarName '$history_flag'))}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<history>} {<-s>} {(DQ ($ Id.VSub_DollarName '$line'))})]
                  spids: [343 356]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: getc
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<ch>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DParen
                              child: 
                                (arith_expr.Binary
                                  op_id: Id.Arith_DEqual
                                  left: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name pb_get>
                                        prefix_op: (Id.VSub_Pound)
                                      )
                                    }
                                  right: {<Id.Lit_Digits 2>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<readline>}) (C {<getc>})]
                  spids: [385 400]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:ch)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ 
                            (braced_var_sub
                              token: <Id.VSub_Name pb_get>
                              suffix_op: 
                                (suffix_op.Slice
                                  begin: {<Id.Lit_Digits 1>}
                                  length: {<Id.Lit_Digits 1>}
                                )
                            )
                          )
                        }
                      spids: [412]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:pb_get)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ <'^'> 
                            (braced_var_sub
                              token: <Id.VSub_Name pb_get>
                              suffix_op: (suffix_op.Slice begin:{<Id.Lit_Digits 2>})
                            )
                          )
                        }
                      spids: [424]
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (command.DParen
                                  child: 
                                    (arith_expr.Binary
                                      op_id: Id.Arith_Great
                                      left: <Id.Lit_ArithVarLike pb_max>
                                      right: {<Id.Lit_Digits 0>}
                                    )
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:pb_unget)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ 
                                    (braced_var_sub
                                      token: <Id.VSub_Name pb_unget>
                                      suffix_op: 
                                        (suffix_op.Slice
                                          begin: {<Id.Lit_Digits 0>}
                                          length: 
                                            {
                                              (word_part.ArithSub
                                                anode: 
                                                  (arith_expr.Binary
                                                    op_id: Id.Arith_Minus
                                                    left: 
                                                      {
                                                        (braced_var_sub
                                                          token: <Id.VSub_Name pb_unget>
                                                          prefix_op: (Id.VSub_Pound)
                                                        )
                                                      }
                                                    right: {<Id.Lit_Digits 1>}
                                                  )
                                              )
                                            }
                                        )
                                    )
                                  )
                                }
                              spids: [450]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:pb_unget)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ <'^'> (${ Id.VSub_Name ch) 
                                    (braced_var_sub
                                      token: <Id.VSub_Name pb_unget>
                                      suffix_op: 
                                        (suffix_op.Slice
                                          begin: {<Id.Lit_Digits 1>}
                                          length: 
                                            {
                                              (word_part.ArithSub
                                                anode: 
                                                  (arith_expr.Binary
                                                    op_id: Id.Arith_Minus
                                                    left: <Id.Lit_ArithVarLike pb_max>
                                                    right: {<Id.Lit_Digits 1>}
                                                  )
                                              )
                                            }
                                        )
                                    ) <Id.Lit_Dollar '$'>
                                  )
                                }
                              spids: [470]
                            )
                          ]
                        )
                      ]
                      spids: [435 447]
                    )
                  ]
                  else_action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:pb_unget)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ <'^'> (${ Id.VSub_Name ch) 
                                (braced_var_sub
                                  token: <Id.VSub_Name pb_unget>
                                  suffix_op: (suffix_op.Slice begin:{<Id.Lit_Digits 1>})
                                )
                              )
                            }
                          spids: [495]
                        )
                      ]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:r)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$ch'))}
                      spids: [512]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: ungetc
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {(DQ ($ Id.VSub_DollarName '$pb_unget'))}
                                  right: {(DQ <'^'> <Id.Lit_Dollar '$'>)}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.Simple
                          words: [
                            {<echo>}
                            {
                              (DQ <'ungetc: nothing more to unget, '> 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\$'>
                                ) <'pb_max='> ($ Id.VSub_DollarName '$pb_max')
                              )
                            }
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_GreatAnd '>&'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<2>}
                            )
                          ]
                          do_fork: T
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<1>}
                        )
                      ]
                    )
                  ]
                  spids: [530 548]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:pb_get)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ <'^'> 
                            (braced_var_sub
                              token: <Id.VSub_Name pb_unget>
                              suffix_op: 
                                (suffix_op.Slice
                                  begin: {<Id.Lit_Digits 1>}
                                  length: {<Id.Lit_Digits 1>}
                                )
                            ) (braced_var_sub token:<Id.VSub_Name pb_get> suffix_op:(suffix_op.Slice begin:{<Id.Lit_Digits 1>}))
                          )
                        }
                      spids: [573]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:pb_unget)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ <'^'> 
                            (braced_var_sub
                              token: <Id.VSub_Name pb_unget>
                              suffix_op: (suffix_op.Slice begin:{<Id.Lit_Digits 2>})
                            )
                          )
                        }
                      spids: [591]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: has_shebangP
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: 
                (command.DBracket
                  expr: 
                    (bool_expr.LogicalAnd
                      left: 
                        (bool_expr.Binary
                          op_id: Id.BoolBinary_EqualTilde
                          left: 
                            {
                              (DQ 
                                (command_sub
                                  left_token: <Id.Left_DollarParen '$('>
                                  child: (C {<head>} {<-1>} {($ Id.VSub_Number '$1')})
                                )
                              )
                            }
                          right: {<Id.Lit_Other '^'> <Id.Lit_Other '#'> <Id.Lit_Other '!'>}
                        )
                      right: 
                        (bool_expr.Binary
                          op_id: Id.BoolBinary_EqualTilde
                          left: 
                            {
                              (DQ 
                                (command_sub
                                  left_token: <Id.Left_DollarParen '$('>
                                  child: (C {<head>} {<-1>} {($ Id.VSub_Number '$1')})
                                )
                              )
                            }
                          right: {<gherkin>}
                        )
                    )
                )
              terminator: <Id.Op_Semi _>
            )
          ]
        )
    )
    (command.ShFunction
      name: strmap_file
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'f='> (DQ ($ Id.VSub_Number '$1'))} {<contents>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<has_shebangP>} {(DQ ($ Id.VSub_DollarName '$f'))})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:contents)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (command_sub
                                  left_token: <Id.Left_DollarParen '$('>
                                  child: 
                                    (command.Pipeline
                                      children: [
                                        (C {<tail>} {<-n> <Id.Lit_Other '+'> <2>} 
                                          {(DQ ($ Id.VSub_DollarName '$f'))}
                                        )
                                        (C {<sed>} {<-e>} {(SQ <'s/^[[:space:]]*//'>)})
                                        (C {<tr>} {<-s>} {(SQ <'\\n'>)} 
                                          {($ Id.VSub_DollarName '$pb_newline')}
                                        )
                                      ]
                                      negated: F
                                    )
                                )
                              )
                            }
                          spids: [682]
                        )
                      ]
                    )
                  ]
                  spids: [670 679]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:contents)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ 
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              child: 
                                (command.Pipeline
                                  children: [
                                    (C {<cat>} {(DQ ($ Id.VSub_DollarName '$f'))})
                                    (C {<sed>} {<-e>} {(SQ <'s/^[[:space:]]*//'>)})
                                    (C {<tr>} {<-s>} {(SQ <'\\n'>)} 
                                      {($ Id.VSub_DollarName '$pb_newline')}
                                    )
                                  ]
                                  negated: F
                                )
                            )
                          )
                        }
                      spids: [723]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:mapped_file)
                  op: assign_op.Equal
                  rhs: {(DQ <'(do '> ($ Id.VSub_DollarName '$contents') <' nil)'>)}
                  spids: [760]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:mapped_file_ptr)
                  op: assign_op.Equal
                  rhs: {<0>}
                  spids: [768]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: strmap_getc
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:r)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (braced_var_sub
                          token: <Id.VSub_Name mapped_file>
                          suffix_op: 
                            (suffix_op.Slice
                              begin: 
                                {
                                  (word_part.ArithSub
                                    anode: 
                                      (arith_expr.UnaryAssign
                                        op_id: Id.Node_PostDPlus
                                        child: <Id.Lit_ArithVarLike mapped_file_ptr>
                                      )
                                  )
                                }
                              length: {<Id.Lit_Digits 1>}
                            )
                        )
                      )
                    }
                  spids: [781]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: strmap_ungetc
      body: (BraceGroup children:[(C {<let>} {<--mapped_file_ptr>})])
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:_getc)
          op: assign_op.Equal
          rhs: {<getc>}
          spids: [813]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:_ungetc)
          op: assign_op.Equal
          rhs: {<ungetc>}
          spids: [816]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:cons_ptr)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [824]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:symbol_ptr)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [827]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:protected_ptr)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [831]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:gensym_counter)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [834]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:array_cntr)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [837]
        )
      ]
    )
    (C {<declare>} {<-A>} {<interned_strings>})
    (C {<declare>} {<-A>} {<car>})
    (C {<declare>} {<-A>} {<cdr>})
    (C {<declare>} {<-A>} {<environments>})
    (C {<declare>} {<-A>} {<recur_frames>})
    (C {<declare>} {<-A>} {<recur_fns>})
    (C {<declare>} {<-A>} {<marks>})
    (C {<declare>} {<-A>} {<global_bindings>})
    (C {<declare>} {<-a>} {<symbols>})
    (C {<declare>} {<-a>} {<protected>})
    (C {<declare>} {<-a>} {<mark_acc>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:heap_increment)
          op: assign_op.Equal
          rhs: {<1500>}
          spids: [909]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:cons_limit)
          op: assign_op.Equal
          rhs: {($ Id.VSub_DollarName '$heap_increment')}
          spids: [912]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:symbol_limit)
          op: assign_op.Equal
          rhs: {($ Id.VSub_DollarName '$heap_increment')}
          spids: [915]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:tag_marker)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                (command_sub
                  left_token: <Id.Left_DollarParen '$('>
                  child: (C {<printf>} {(SQ <'\\036'>)})
                )
              )
            }
          spids: [919]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:atag)
          op: assign_op.Equal
          rhs: {(DQ (${ Id.VSub_Name tag_marker) <003>)}
          spids: [931]
        )
      ]
    )
    (C {<declare>} {<-A>} 
      {<Id.Lit_VarLike 'type_tags='> 
        (word_part.AssocArrayLiteral
          left: <Id.Op_LParen _>
          pairs: [
            {<000>}
            {<integer>}
            {<001>}
            {<symbol>}
            {<002>}
            {<cons>}
            {<003>}
            {<vector>}
            {<004>}
            {<keyword>}
          ]
        )
      }
    )
    (command.ShFunction
      name: type
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Number 1>
                                          suffix_op: 
                                            (suffix_op.Slice
                                              begin: {<Id.Lit_Digits 0>}
                                              length: {<Id.Lit_Digits 1>}
                                            )
                                        )
                                      )
                                    }
                                  right: {(DQ ($ Id.VSub_DollarName '$tag_marker'))}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:r)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name type_tags>
                                  bracket_op: 
                                    (bracket_op.ArrayIndex
                                      expr: 
                                        {
                                          (braced_var_sub
                                            token: <Id.VSub_Number 1>
                                            suffix_op: 
                                              (suffix_op.Slice
                                                begin: {<Id.Lit_Digits 1>}
                                                length: {<Id.Lit_Digits 3>}
                                              )
                                          )
                                        }
                                    )
                                )
                              )
                            }
                          spids: [1010]
                        )
                      ]
                    )
                  ]
                  spids: [984 1007]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:r)
                      op: assign_op.Equal
                      rhs: {<string>}
                      spids: [1030]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: strip_tag
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: 
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:r)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ 
                            (braced_var_sub
                              token: <Id.VSub_Number 1>
                              suffix_op: (suffix_op.Slice begin:{<Id.Lit_Digits 4>})
                            )
                          )
                        }
                      spids: [1045]
                    )
                  ]
                )
              terminator: <Id.Op_Semi _>
            )
          ]
        )
    )
    (command.ShFunction
      name: typeP
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'obj='> (DQ ($ Id.VSub_Number '$1'))} 
              {<Id.Lit_VarLike 'tag='> (DQ ($ Id.VSub_Number '$2'))}
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<type>} {(DQ ($ Id.VSub_DollarName '$obj'))})
                (command.DBracket
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_GlobDEqual
                      left: {($ Id.VSub_DollarName '$r')}
                      right: {(DQ ($ Id.VSub_DollarName '$tag'))}
                    )
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: make_integer
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: 
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:r)
                      op: assign_op.Equal
                      rhs: {(DQ (${ Id.VSub_Name tag_marker) <000> (${ Id.VSub_Number 1))}
                      spids: [1107]
                    )
                  ]
                )
              terminator: <Id.Op_Semi _>
            )
          ]
        )
    )
    (command.ShFunction
      name: make_keyword
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: 
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:r)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ (${ Id.VSub_Name tag_marker) <004> 
                            (braced_var_sub
                              token: <Id.VSub_Number 1>
                              suffix_op: (suffix_op.Slice begin:{<Id.Lit_Digits 1>})
                            )
                          )
                        }
                      spids: [1128]
                    )
                  ]
                )
              terminator: <Id.Op_Semi _>
            )
          ]
        )
    )
    (command.ShFunction
      name: intern_symbol
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_n
                                  child: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Name interned_strings>
                                          bracket_op: 
                                            (bracket_op.ArrayIndex
                                              expr: {($ Id.VSub_Number '$1')}
                                            )
                                        )
                                      )
                                    }
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:r)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name interned_strings>
                                  bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_Number '$1')})
                                )
                              )
                            }
                          spids: [1173]
                        )
                      ]
                    )
                  ]
                  spids: [1152 1170]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:symbol_ptr)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ 
                            (word_part.ArithSub
                              anode: 
                                (arith_expr.Binary
                                  op_id: Id.Arith_Plus
                                  left: <Id.Lit_ArithVarLike symbol_ptr>
                                  right: {<Id.Lit_Digits 1>}
                                )
                            )
                          )
                        }
                      spids: [1187]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: 
                        (sh_lhs_expr.IndexedName
                          name: interned_strings
                          index: {(DQ ($ Id.VSub_Number '$1'))}
                        )
                      op: assign_op.Equal
                      rhs: {(DQ (${ Id.VSub_Name tag_marker) <001> (${ Id.VSub_Name symbol_ptr))}
                      spids: [1200]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: 
                        (sh_lhs_expr.IndexedName
                          name: symbols
                          index: {(DQ ($ Id.VSub_DollarName '$symbol_ptr'))}
                        )
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_Number '$1'))}
                      spids: [1220]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:r)
                      op: assign_op.Equal
                      rhs: {(DQ (${ Id.VSub_Name tag_marker) <001> (${ Id.VSub_Name symbol_ptr))}
                      spids: [1234]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: defprim
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<intern_symbol>} {(DQ ($ Id.VSub_Number '$1'))})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:sym_ptr)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                      spids: [1266]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<intern_symbol>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<printf>} {(SQ <'#<primitive:%s>'>)} {(DQ ($ Id.VSub_Number '$1'))})
                      )
                    )
                  }
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:prim_ptr)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                      spids: [1290]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: 
                    (sh_lhs_expr.IndexedName
                      name: global_bindings
                      index: {(DQ ($ Id.VSub_DollarName '$sym_ptr'))}
                    )
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$prim_ptr')}
                  spids: [1296]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:r)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$prim_ptr'))}
                  spids: [1308]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: cons
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'the_car='> (DQ ($ Id.VSub_Number '$1'))} 
              {<Id.Lit_VarLike 'the_cdr='> (DQ ($ Id.VSub_Number '$2'))}
            )
            (C {<mark>} {(DQ ($ Id.VSub_DollarName '$the_car'))})
            (C {<mark>} {(DQ ($ Id.VSub_DollarName '$the_cdr'))})
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_n
                              child: 
                                {
                                  (DQ 
                                    (braced_var_sub
                                      token: <Id.VSub_Name marks>
                                      bracket_op: 
                                        (bracket_op.ArrayIndex
                                          expr: 
                                            {(${ Id.VSub_Name tag_marker) <Id.Lit_Digits 002> 
                                              (${ Id.VSub_Name cons_ptr)
                                            }
                                        )
                                    )
                                  )
                                }
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (C {<unset>} 
                      {<Id.Lit_ArrayLhsOpen 'marks['> 
                        (DQ (${ Id.VSub_Name tag_marker) <002> 
                          (word_part.ArithSub
                            anode: 
                              (arith_expr.UnaryAssign
                                op_id: Id.Node_PostDPlus
                                child: <Id.Lit_ArithVarLike cons_ptr>
                              )
                          )
                        ) <Id.Lit_RBracket ']'>
                      }
                    )
                  ]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {($ Id.VSub_DollarName '$cons_ptr')}
                                  right: {($ Id.VSub_DollarName '$cons_limit')}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<gc>})]
                  spids: [1397 1410]
                )
              ]
            )
            (C {<unset>} 
              {<Id.Lit_ArrayLhsOpen 'environments['> 
                (DQ (${ Id.VSub_Name tag_marker) <002> (${ Id.VSub_Name cons_ptr)) <Id.Lit_RBracket ']'>
              }
            )
            (C {<unset>} 
              {<Id.Lit_ArrayLhsOpen 'recur_frames['> 
                (DQ (${ Id.VSub_Name tag_marker) <002> (${ Id.VSub_Name cons_ptr)) <Id.Lit_RBracket ']'>
              }
            )
            (C {<unset>} 
              {<Id.Lit_ArrayLhsOpen 'recur_fns['> 
                (DQ (${ Id.VSub_Name tag_marker) <002> (${ Id.VSub_Name cons_ptr)) <Id.Lit_RBracket ']'>
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: 
                    (sh_lhs_expr.IndexedName
                      name: car
                      index: {(DQ (${ Id.VSub_Name tag_marker) <002> (${ Id.VSub_Name cons_ptr))}
                    )
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$the_car'))}
                  spids: [1464]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: 
                    (sh_lhs_expr.IndexedName
                      name: cdr
                      index: {(DQ (${ Id.VSub_Name tag_marker) <002> (${ Id.VSub_Name cons_ptr))}
                    )
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$the_cdr'))}
                  spids: [1490]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:r)
                  op: assign_op.Equal
                  rhs: {(DQ (${ Id.VSub_Name tag_marker) <002> (${ Id.VSub_Name cons_ptr))}
                  spids: [1516]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:cons_ptr)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (word_part.ArithSub
                          anode: 
                            (arith_expr.Binary
                              op_id: Id.Arith_Plus
                              left: <Id.Lit_ArithVarLike cons_ptr>
                              right: {<Id.Lit_Digits 1>}
                            )
                        )
                      )
                    }
                  spids: [1528]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: gensym
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:gensym_counter)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (word_part.ArithSub
                        anode: 
                          (arith_expr.Binary
                            op_id: Id.Arith_Plus
                            left: <Id.Lit_ArithVarLike gensym_counter>
                            right: {<Id.Lit_Digits 1>}
                          )
                      )
                    }
                  spids: [1550]
                )
              ]
            )
            (C {<intern_symbol>} {(DQ <G__> (${ Id.VSub_Name gensym_counter))})
          ]
        )
    )
    (command.ShFunction
      name: new_array
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:r)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ <arr> 
                        (word_part.ArithSub
                          anode: 
                            (arith_expr.UnaryAssign
                              op_id: Id.Node_PostDPlus
                              child: <Id.Lit_ArithVarLike array_cntr>
                            )
                        )
                      )
                    }
                  spids: [1580]
                )
              ]
            )
            (C {<declare>} {<-a>} {($ Id.VSub_DollarName '$r')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:r)
                  op: assign_op.Equal
                  rhs: {(DQ (${ Id.VSub_Name atag) (${ Id.VSub_Name r))}
                  spids: [1598]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: vset
      body: 
        (BraceGroup
          children: [
            (C {<strip_tag>} {(DQ ($ Id.VSub_Number '$1'))})
            (C {<eval>} 
              {
                (DQ (${ Id.VSub_Name r) <'['> (${ Id.VSub_Number 2) <']='> 
                  (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) (${ Id.VSub_Number 3) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>)
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:r)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number '$1'))}
                  spids: [1644]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: vget
      body: 
        (BraceGroup
          children: [
            (C {<strip_tag>} {(DQ ($ Id.VSub_Number '$1'))})
            (C {<eval>} 
              {
                (DQ <'r='> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'{'> 
                  (${ Id.VSub_Name r) <'['> (${ Id.VSub_Number 2) <']}'>
                )
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: count_array
      body: 
        (BraceGroup
          children: [
            (C {<strip_tag>} {(DQ ($ Id.VSub_Number '$1'))})
            (C {<eval>} 
              {
                (DQ <'r='> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'{#'> 
                  (${ Id.VSub_Name r) <'[@]}'>
                )
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: append
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<i>})
            (C {<strip_tag>} {(DQ ($ Id.VSub_Number '$1'))})
            (C {<eval>} 
              {
                (DQ <'i='> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'{#'> 
                  (${ Id.VSub_Name r) <'[@]}'>
                )
              }
            )
            (C {<eval>} 
              {
                (DQ (${ Id.VSub_Name r) <'['> (${ Id.VSub_Name i) <']='> 
                  (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) (${ Id.VSub_Number 2) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>)
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:r)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number '$1'))}
                  spids: [1765]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: append_all
      body: 
        (BraceGroup
          children: [
            (C {<strip_tag>} {(DQ ($ Id.VSub_Number '$1'))})
            (C {<local>} {<Id.Lit_VarLike 'a1='> (DQ ($ Id.VSub_DollarName '$r'))})
            (C {<strip_tag>} {(DQ ($ Id.VSub_Number '$2'))})
            (C {<local>} {<Id.Lit_VarLike 'a2='> (DQ ($ Id.VSub_DollarName '$r'))})
            (C {<local>} {<len1>} {<len2>})
            (C {<eval>} 
              {
                (DQ <'len1='> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'{#'> 
                  (${ Id.VSub_Name a1) <'[@]}'>
                )
              }
            )
            (C {<eval>} 
              {
                (DQ <'len2='> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'{#'> 
                  (${ Id.VSub_Name a2) <'[@]}'>
                )
              }
            )
            (C {<local>} {<Id.Lit_VarLike 'i='> <0>})
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.DParen
                          child: 
                            (arith_expr.Binary
                              op_id: Id.Arith_Less
                              left: <Id.Lit_ArithVarLike i>
                              right: <Id.Lit_ArithVarLike len2>
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (C {<eval>} 
                      {
                        (DQ (${ Id.VSub_Name a1) <'[(('> (${ Id.VSub_Name i) <' + '> 
                          (${ Id.VSub_Name len1) <'))]='> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) 
                          (word_part.EscapedLiteral
                            token: <Id.Lit_EscapedChar '\\$'>
                          ) <'{'> (${ Id.VSub_Name a2) <'['> (${ Id.VSub_Name i) <']}'> 
                          (word_part.EscapedLiteral
                            token: <Id.Lit_EscapedChar '\\"'>
                          )
                        )
                      }
                    )
                    (command.DParen
                      child: 
                        (arith_expr.UnaryAssign
                          op_id: Id.Node_PostDPlus
                          child: <Id.Lit_ArithVarLike i>
                        )
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:r)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number '$1'))}
                  spids: [1904]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: prepend
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<i>} {<len>})
            (C {<strip_tag>} {(DQ ($ Id.VSub_Number '$2'))})
            (C {<eval>} 
              {
                (DQ <'len='> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'{#'> 
                  (${ Id.VSub_Name r) <'[@]}'>
                )
              }
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.DParen
                          child: 
                            (arith_expr.Binary
                              op_id: Id.Arith_Great
                              left: <Id.Lit_ArithVarLike len>
                              right: {<Id.Lit_Digits 0>}
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (C {<eval>} 
                      {
                        (DQ (${ Id.VSub_Name r) <'['> (${ Id.VSub_Name len) <']='> 
                          (word_part.EscapedLiteral
                            token: <Id.Lit_EscapedChar '\\"'>
                          ) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'{'> (${ Id.VSub_Name r) <'[((len - 1))]}'> 
                          (word_part.EscapedLiteral
                            token: <Id.Lit_EscapedChar '\\"'>
                          )
                        )
                      }
                    )
                    (command.DParen
                      child: 
                        (arith_expr.UnaryAssign
                          op_id: Id.Node_PostDMinus
                          child: <Id.Lit_ArithVarLike len>
                        )
                    )
                  ]
                )
            )
            (C {<eval>} 
              {
                (DQ (${ Id.VSub_Name r) <'[0]='> 
                  (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) ($ Id.VSub_Number '$1') (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>)
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:r)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number '$2'))}
                  spids: [2006]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: dup
      body: 
        (BraceGroup
          children: [
            (C {<new_array>})
            (C {<local>} {<Id.Lit_VarLike 'aptr='> (DQ ($ Id.VSub_DollarName '$r'))})
            (C {<strip_tag>} {(DQ ($ Id.VSub_DollarName '$aptr'))})
            (C {<local>} {<Id.Lit_VarLike 'narr='> (DQ ($ Id.VSub_DollarName '$r'))})
            (C {<strip_tag>} {(DQ ($ Id.VSub_Number '$1'))})
            (C {<local>} {<len>})
            (C {<eval>} 
              {
                (DQ <'len='> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'{#'> 
                  (${ Id.VSub_Name r) <'[@]}'>
                )
              }
            )
            (C {<local>} {<Id.Lit_VarLike 'i='> <0>})
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.DParen
                          child: 
                            (arith_expr.Binary
                              op_id: Id.Arith_Less
                              left: <Id.Lit_ArithVarLike i>
                              right: <Id.Lit_ArithVarLike len>
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (C {<eval>} 
                      {
                        (DQ (${ Id.VSub_Name narr) <'['> (${ Id.VSub_Name i) <']='> 
                          (word_part.EscapedLiteral
                            token: <Id.Lit_EscapedChar '\\"'>
                          ) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'{'> (${ Id.VSub_Name r) <'['> 
                          (${ Id.VSub_Name i) <']}'> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>)
                        )
                      }
                    )
                    (command.DParen
                      child: 
                        (arith_expr.UnaryAssign
                          op_id: Id.Node_PostDPlus
                          child: <Id.Lit_ArithVarLike i>
                        )
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:r)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$aptr'))}
                  spids: [2129]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: concat
      body: 
        (BraceGroup
          children: [
            (C {<dup>} {(DQ ($ Id.VSub_Number '$1'))})
            (C {<append_all>} {(DQ ($ Id.VSub_DollarName '$r'))} {(DQ ($ Id.VSub_Number '$2'))})
          ]
        )
    )
    (command.ShFunction
      name: vector
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'v='> (DQ ($ Id.VSub_Number '$2'))})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.LogicalOr
                                  left: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobDEqual
                                      left: {(DQ ($ Id.VSub_DollarName '$EMPTY'))}
                                      right: {(DQ ($ Id.VSub_DollarName '$v'))}
                                    )
                                  right: 
                                    (bool_expr.LogicalOr
                                      left: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: {(DQ ($ Id.VSub_DollarName '$v'))}
                                        )
                                      right: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$NIL'))}
                                          right: {(DQ ($ Id.VSub_DollarName '$v'))}
                                        )
                                    )
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<new_array>})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:v)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                          spids: [2223]
                        )
                      ]
                    )
                  ]
                  spids: [2179 2216]
                )
              ]
            )
            (C {<prepend>} {($ Id.VSub_Number '$1')} {($ Id.VSub_DollarName '$v')})
          ]
        )
    )
    (command.ShFunction
      name: protect
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:protected_ptr)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (word_part.ArithSub
                          anode: 
                            (arith_expr.Binary
                              op_id: Id.Arith_Plus
                              left: <Id.Lit_ArithVarLike protected_ptr>
                              right: {<Id.Lit_Digits 1>}
                            )
                        )
                      )
                    }
                  spids: [2248]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: 
                    (sh_lhs_expr.IndexedName
                      name: protected
                      index: {(DQ ($ Id.VSub_DollarName '$protected_ptr'))}
                    )
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number '$1'))}
                  spids: [2261]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: unprotect
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: 
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:protected_ptr)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ 
                            (word_part.ArithSub
                              anode: 
                                (arith_expr.Binary
                                  op_id: Id.Arith_Minus
                                  left: <Id.Lit_ArithVarLike protected_ptr>
                                  right: {<Id.Lit_Digits 1>}
                                )
                            )
                          )
                        }
                      spids: [2283]
                    )
                  ]
                )
              terminator: <Id.Op_Semi _>
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:acc_count)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [2299]
        )
      ]
    )
    (command.ShFunction
      name: mark_seq
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'object='> (DQ ($ Id.VSub_Number '$1'))})
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Id.Op_DAmp]
                          children: [
                            (C {<typeP>} {(DQ ($ Id.VSub_DollarName '$object'))} {<cons>})
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_z
                                  child: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Name marks>
                                          bracket_op: 
                                            (bracket_op.ArrayIndex
                                              expr: {($ Id.VSub_DollarName '$object')}
                                            )
                                        )
                                      )
                                    }
                                )
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: 
                            (sh_lhs_expr.IndexedName
                              name: marks
                              index: {(DQ ($ Id.VSub_DollarName '$object'))}
                            )
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [2349]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: 
                            (sh_lhs_expr.IndexedName
                              name: mark_acc
                              index: 
                                (arith_expr.UnaryAssign
                                  op_id: Id.Node_PostDPlus
                                  child: <Id.Lit_ArithVarLike acc_count>
                                )
                            )
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name car>
                                  bracket_op: 
                                    (bracket_op.ArrayIndex
                                      expr: {($ Id.VSub_DollarName '$object')}
                                    )
                                )
                              )
                            }
                          spids: [2361]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:object)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name cdr>
                                  bracket_op: 
                                    (bracket_op.ArrayIndex
                                      expr: {($ Id.VSub_DollarName '$object')}
                                    )
                                )
                              )
                            }
                          spids: [2379]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<typeP>} {(DQ ($ Id.VSub_DollarName '$object'))} {<vector>})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<count_array>} {(DQ ($ Id.VSub_DollarName '$object'))})
                    (C {<local>} {<i>} {<Id.Lit_VarLike 'sz='> (DQ ($ Id.VSub_DollarName '$r'))})
                    (command.ForExpr
                      init: 
                        (arith_expr.BinaryAssign
                          op_id: Id.Arith_Equal
                          left: <Id.Lit_ArithVarLike i>
                          right: {<Id.Lit_Digits 0>}
                        )
                      cond: 
                        (arith_expr.Binary
                          op_id: Id.Arith_Less
                          left: <Id.Lit_ArithVarLike i>
                          right: <Id.Lit_ArithVarLike sz>
                        )
                      update: 
                        (arith_expr.UnaryAssign
                          op_id: Id.Node_PostDPlus
                          child: <Id.Lit_ArithVarLike i>
                        )
                      body: 
                        (command.DoGroup
                          children: [
                            (C {<vget>} {(DQ ($ Id.VSub_DollarName '$object'))} 
                              {($ Id.VSub_DollarName '$i')}
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.IndexedName
                                      name: mark_acc
                                      index: 
                                        (arith_expr.UnaryAssign
                                          op_id: Id.Node_PostDPlus
                                          child: <Id.Lit_ArithVarLike acc_count>
                                        )
                                    )
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                                  spids: [2456]
                                )
                              ]
                            )
                          ]
                        )
                    )
                  ]
                  spids: [2393 2405]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: mark
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:acc_count)
                  op: assign_op.Equal
                  rhs: {<0>}
                  spids: [2484]
                )
              ]
            )
            (C {<mark_seq>} {(DQ ($ Id.VSub_Number '$1'))})
            (C {<local>} {<i>})
            (command.ForExpr
              init: 
                (arith_expr.BinaryAssign
                  op_id: Id.Arith_Equal
                  left: <Id.Lit_ArithVarLike i>
                  right: {<Id.Lit_Digits 0>}
                )
              cond: 
                (arith_expr.Binary
                  op_id: Id.Arith_Less
                  left: <Id.Lit_ArithVarLike i>
                  right: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name mark_acc>
                        prefix_op: (Id.VSub_Pound)
                        bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                      )
                    }
                )
              update: (arith_expr.UnaryAssign op_id:Id.Node_PostDPlus child:<Id.Lit_ArithVarLike i>)
              body: 
                (command.DoGroup
                  children: [
                    (C {<mark_seq>} 
                      {
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name mark_acc>
                            bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName '$i')})
                          )
                        )
                      }
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:mark_acc)
                  op: assign_op.Equal
                  rhs: {(sh_array_literal left:<Id.Op_LParen _>)}
                  spids: [2543]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: gc
      body: 
        (BraceGroup
          children: [
            (command.Simple
              words: [{<echo>} {(DQ <GC...>)}]
              redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
              do_fork: T
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:IFS)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$DEFAULT_IFS'))}
                  spids: [2567]
                )
              ]
            )
            (C {<mark>} {(DQ ($ Id.VSub_DollarName '$current_env'))})
            (command.ForEach
              iter_name: k
              iter_words: [
                {
                  (DQ 
                    (braced_var_sub
                      token: <Id.VSub_Name environments>
                      prefix_op: (Id.VSub_Bang)
                      bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                    )
                  )
                }
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Sentence
                      child: 
                        (C {<mark>} 
                          {
                            (DQ 
                              (braced_var_sub
                                token: <Id.VSub_Name environments>
                                bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName '$k')})
                              )
                            )
                          }
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
            )
            (command.ForEach
              iter_name: k
              iter_words: [
                {
                  (DQ 
                    (braced_var_sub
                      token: <Id.VSub_Name protected>
                      prefix_op: (Id.VSub_Bang)
                      bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                    )
                  )
                }
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Sentence
                      child: 
                        (C {<mark>} 
                          {
                            (DQ 
                              (braced_var_sub
                                token: <Id.VSub_Name protected>
                                bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName '$k')})
                              )
                            )
                          }
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
            )
            (command.ForEach
              iter_name: k
              iter_words: [
                {
                  (DQ 
                    (braced_var_sub
                      token: <Id.VSub_Name stack>
                      prefix_op: (Id.VSub_Bang)
                      bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                    )
                  )
                }
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Sentence
                      child: 
                        (C {<mark>} 
                          {
                            (DQ 
                              (braced_var_sub
                                token: <Id.VSub_Name stack>
                                bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName '$k')})
                              )
                            )
                          }
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
            )
            (command.ForEach
              iter_name: k
              iter_words: [
                {
                  (DQ 
                    (braced_var_sub
                      token: <Id.VSub_Name global_bindings>
                      prefix_op: (Id.VSub_Bang)
                      bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                    )
                  )
                }
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Sentence
                      child: 
                        (C {<mark>} 
                          {
                            (DQ 
                              (braced_var_sub
                                token: <Id.VSub_Name global_bindings>
                                bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName '$k')})
                              )
                            )
                          }
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:cons_ptr)
                  op: assign_op.Equal
                  rhs: {<0>}
                  spids: [2716]
                )
              ]
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_n
                              child: 
                                {
                                  (DQ 
                                    (braced_var_sub
                                      token: <Id.VSub_Name marks>
                                      bracket_op: 
                                        (bracket_op.ArrayIndex
                                          expr: 
                                            {(${ Id.VSub_Name tag_marker) <Id.Lit_Digits 002> 
                                              (${ Id.VSub_Name cons_ptr)
                                            }
                                        )
                                    )
                                  )
                                }
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (C {<unset>} 
                      {<Id.Lit_ArrayLhsOpen 'marks['> 
                        (DQ (${ Id.VSub_Name tag_marker) <002> 
                          (word_part.ArithSub
                            anode: 
                              (arith_expr.UnaryAssign
                                op_id: Id.Node_PostDPlus
                                child: <Id.Lit_ArithVarLike cons_ptr>
                              )
                          )
                        ) <Id.Lit_RBracket ']'>
                      }
                    )
                  ]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {($ Id.VSub_DollarName '$cons_ptr')}
                                  right: {($ Id.VSub_DollarName '$cons_limit')}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Simple
                      words: [{<echo>} {(DQ <'expanding heap...'>)}]
                      redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                      do_fork: T
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:cons_limit)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (word_part.ArithSub
                                anode: 
                                  (arith_expr.Binary
                                    op_id: Id.Arith_Plus
                                    left: <Id.Lit_ArithVarLike cons_limit>
                                    right: <Id.Lit_ArithVarLike heap_increment>
                                  )
                              )
                            }
                          spids: [2793]
                        )
                      ]
                    )
                  ]
                  spids: [2767 2780]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: interpret_token
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_EqualTilde
                      left: {(DQ ($ Id.VSub_Number '$1'))}
                      right: 
                        {<Id.Lit_Other '^'> <-> <Id.Lit_Other '?'> <Id.Lit_Other '['> <Id.Lit_Other '['> 
                          <Id.Lit_Other ':'> <digit> <Id.Lit_Other ':'> <Id.Lit_Other ']'> <Id.Lit_Other ']'> <Id.Lit_Other '+'> <Id.Lit_Other '$'>
                        }
                    )
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:r)
                      op: assign_op.Equal
                      rhs: {<integer>}
                      spids: [2847]
                    )
                  ]
                )
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_EqualTilde
                      left: {(DQ ($ Id.VSub_Number '$1'))}
                      right: 
                        {<Id.Lit_Other '^'> <Id.Lit_Other ':'> <Id.Lit_Other '('> <Id.Lit_Other '['> 
                          <Id.Lit_Other '['> <Id.Lit_Other ':'> <graph> <Id.Lit_Other ':'> <Id.Lit_Other ']'> <Id.Lit_Other ']'> <Id.Lit_Other '|'> 
                          ($ Id.VSub_DollarName '$pb_star') <Id.Lit_Other ')'> <Id.Lit_Other '+'> <Id.Lit_Other '$'>
                        }
                    )
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:r)
                      op: assign_op.Equal
                      rhs: {<keyword>}
                      spids: [2885]
                    )
                  ]
                )
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_EqualTilde
                      left: {(DQ ($ Id.VSub_Number '$1'))}
                      right: 
                        {<Id.Lit_Other '^'> <Id.Lit_Other '('> <Id.Lit_Other '['> <Id.Lit_Other '['> 
                          <Id.Lit_Other ':'> <graph> <Id.Lit_Other ':'> <Id.Lit_Other ']'> <Id.Lit_Other ']'> <Id.Lit_Other '|'> 
                          ($ Id.VSub_DollarName '$pb_star') <Id.Lit_Other ')'> <Id.Lit_Other '+'> <Id.Lit_Other '$'>
                        }
                    )
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:r)
                      op: assign_op.Equal
                      rhs: {<symbol>}
                      spids: [2922]
                    )
                  ]
                )
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<1>})
          ]
        )
    )
    (command.ShFunction
      name: read_token
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'token='> (DQ )})
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: (C {($ Id.VSub_DollarName '$_getc')})
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_EqualTilde
                                          left: {(DQ ($ Id.VSub_DollarName '$r'))}
                                          right: 
                                            {<Id.Lit_Other '('> (SQ <'('>) <Id.Lit_Other '|'> (SQ <')'>) 
                                              <Id.Lit_Other '|'> (SQ <'['>) <Id.Lit_Other '|'> (SQ <']'>) <Id.Lit_Other '|'> <Id.Lit_Other '['> <Id.Lit_Other '['> 
                                              <Id.Lit_Other ':'> <space> <Id.Lit_Other ':'> <Id.Lit_Other ']'> <Id.Lit_Other ']'> <Id.Lit_Other '|'> 
                                              ($ Id.VSub_DollarName '$pb_newline') <Id.Lit_Other '|'> <Id.Lit_Other ','> <Id.Lit_Other ')'>
                                            }
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {($ Id.VSub_DollarName '$_ungetc')})
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Break break>
                                )
                              ]
                            )
                          ]
                          spids: [2959 3002]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:token)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ (${ Id.VSub_Name token) 
                                    (braced_var_sub
                                      token: <Id.VSub_Name r>
                                      suffix_op: 
                                        (suffix_op.PatSub
                                          pat: 
                                            {
                                              (word_part.EscapedLiteral
                                                token: <Id.Lit_EscapedChar '\\*'>
                                              )
                                            }
                                          replace: {(${ Id.VSub_Name pb_star)}
                                          replace_mode: Id.Undefined_Tok
                                        )
                                    )
                                  )
                                }
                              spids: [3015]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_DollarName '$token'))} 
                  {<Id.Lit_RBracket ']'>}
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<1>}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<interpret_token>} {(DQ ($ Id.VSub_DollarName '$token'))})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName '$r'))}
                      arms: [
                        (case_arm
                          pat_list: [{<symbol>}]
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<intern_symbol>} {(DQ ($ Id.VSub_DollarName '$token'))})
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Return return>
                                )
                              ]
                            )
                          ]
                          spids: [3076 3077 3089 -1]
                        )
                        (case_arm
                          pat_list: [{<integer>}]
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<make_integer>} {(DQ ($ Id.VSub_DollarName '$token'))})
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Return return>
                                )
                              ]
                            )
                          ]
                          spids: [3092 3093 3105 -1]
                        )
                        (case_arm
                          pat_list: [{<keyword>}]
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<make_keyword>} {(DQ ($ Id.VSub_DollarName '$token'))})
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Return return>
                                )
                              ]
                            )
                          ]
                          spids: [3108 3109 3121 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (C {<error>} 
                              {(DQ <'unknown token type: \''> ($ Id.VSub_DollarName '$r') <'\''>)}
                            )
                          ]
                          spids: [3124 3125 -1 3136]
                        )
                      ]
                    )
                  ]
                  spids: [3055 3064]
                )
              ]
              else_action: [(C {<error>} {(DQ <'unknown token: \''> (${ Id.VSub_Name token) <'\''>)})]
            )
          ]
        )
    )
    (command.ShFunction
      name: skip_blanks
      body: 
        (BraceGroup
          children: [
            (C {($ Id.VSub_DollarName '$_getc')})
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_EqualTilde
                              left: {(DQ ($ Id.VSub_DollarName '$r'))}
                              right: 
                                {<Id.Lit_Other '('> <Id.Lit_Other '['> <Id.Lit_Other '['> 
                                  <Id.Lit_Other ':'> <space> <Id.Lit_Other ':'> <Id.Lit_Other ']'> <Id.Lit_Other ']'> <Id.Lit_Other '|'> 
                                  ($ Id.VSub_DollarName '$pb_newline') <Id.Lit_Other '|'> <Id.Lit_Other ','> <Id.Lit_Other ')'>
                                }
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.Sentence
                      child: (C {($ Id.VSub_DollarName '$_getc')})
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
            )
            (C {($ Id.VSub_DollarName '$_ungetc')})
          ]
        )
    )
    (command.ShFunction
      name: skip_comment
      body: 
        (BraceGroup
          children: [
            (C {($ Id.VSub_DollarName '$_getc')})
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobNEqual
                              left: {(DQ ($ Id.VSub_DollarName '$r'))}
                              right: {(DQ ($ Id.VSub_DollarName '$pb_newline'))}
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.Sentence
                      child: (C {($ Id.VSub_DollarName '$_getc')})
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: read_list
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<ch>} {<read1>} {<read2>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(command.Sentence child:(C {<lisp_read>}) terminator:<Id.Op_Semi _>)]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:read1)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                          spids: [3269]
                        )
                      ]
                    )
                  ]
                  spids: [3261 3266]
                )
              ]
              else_action: [
                (C {($ Id.VSub_DollarName '$_getc')})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:r)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$NIL'))}
                      spids: [3281]
                    )
                  ]
                )
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {($ Id.VSub_DollarName '$_getc')})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:ch)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                      spids: [3297]
                    )
                  ]
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$ch'))}
              arms: [
                (case_arm
                  pat_list: [{(DQ <.>)}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<lisp_read>})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:read2)
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                              spids: [3322]
                            )
                          ]
                        )
                      ]
                    )
                    (C {<skip_blanks>})
                    (C {($ Id.VSub_DollarName '$_getc')})
                    (C {<cons>} {(DQ ($ Id.VSub_DollarName '$read1'))} 
                      {(DQ ($ Id.VSub_DollarName '$read2'))}
                    )
                  ]
                  spids: [3312 3315 3345 -1]
                )
                (case_arm
                  pat_list: [{(DQ <')'>)}]
                  action: [
                    (C {<cons>} {(DQ ($ Id.VSub_DollarName '$read1'))} {($ Id.VSub_DollarName '$NIL')})
                  ]
                  spids: [3348 3351 3361 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (C {($ Id.VSub_DollarName '$_ungetc')})
                    (C {<read_list>})
                    (C {<cons>} {(DQ ($ Id.VSub_DollarName '$read1'))} {(DQ ($ Id.VSub_DollarName '$r'))})
                  ]
                  spids: [3364 3365 -1 3385]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: read_vector
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<ch>} {<read1>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(command.Sentence child:(C {<lisp_read>}) terminator:<Id.Op_Semi _>)]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:read1)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                          spids: [3412]
                        )
                      ]
                    )
                  ]
                  spids: [3404 3409]
                )
              ]
              else_action: [
                (C {<getc>})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:r)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$EMPTY'))}
                      spids: [3424]
                    )
                  ]
                )
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (C {<skip_blanks>})
            (C {<getc>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {(DQ ($ Id.VSub_DollarName '$r'))}
                                  right: {(DQ <']'>)}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<vector>} {(DQ ($ Id.VSub_DollarName '$read1'))} 
                      {(DQ ($ Id.VSub_DollarName '$EMPTY'))}
                    )
                  ]
                  spids: [3442 3459]
                )
              ]
              else_action: [
                (C {<ungetc>})
                (C {<skip_blanks>})
                (C {<read_vector>})
                (C {<vector>} {(DQ ($ Id.VSub_DollarName '$read1'))} {(DQ ($ Id.VSub_DollarName '$r'))})
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: read_string
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 's='> (DQ )})
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [(command.Sentence child:(C {<true>}) terminator:<Id.Op_Semi _>)]
                )
              body: 
                (command.DoGroup
                  children: [
                    (C {($ Id.VSub_DollarName '$_getc')})
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$r'))}
                                          right: 
                                            {
                                              (DQ 
                                                (word_part.EscapedLiteral
                                                  token: <Id.Lit_EscapedChar '\\\\'>
                                                )
                                              )
                                            }
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {($ Id.VSub_DollarName '$_getc')})
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_GlobDEqual
                                                  left: {(DQ ($ Id.VSub_DollarName '$r'))}
                                                  right: {(SQ <'"'>)}
                                                )
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:s)
                                          op: assign_op.Equal
                                          rhs: {(DQ (${ Id.VSub_Name s) (${ Id.VSub_Name r))}
                                          spids: [3569]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [3549 3566]
                                )
                              ]
                              else_action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:s)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (DQ (${ Id.VSub_Name s) 
                                            (word_part.EscapedLiteral
                                              token: <Id.Lit_EscapedChar '\\\\'>
                                            ) (${ Id.VSub_Name r)
                                          )
                                        }
                                      spids: [3583]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                          spids: [3526 3543]
                        )
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$r'))}
                                          right: {(SQ <'"'>)}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                          spids: [3598 3615]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:s)
                              op: assign_op.Equal
                              rhs: {(DQ (${ Id.VSub_Name s) (${ Id.VSub_Name r))}
                              spids: [3624]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:r)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: 
                            (command.Pipeline
                              children: [
                                (C {<echo>} {(DQ ($ Id.VSub_DollarName '$s'))})
                                (C {<tr>} {(DQ ($ Id.VSub_DollarName '$pb_star'))} {(SQ <'*'>)})
                              ]
                              negated: F
                            )
                        )
                      )
                    }
                  spids: [3641]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: lisp_read
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<ch>} {<read1>} {<read2>} {<read3>} {<read4>})
            (command.Sentence child:(C {<skip_blanks>}) terminator:<Id.Op_Semi _>)
            (command.Sentence
              child: (C {($ Id.VSub_DollarName '$_getc')})
              terminator: <Id.Op_Semi _>
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:ch)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                  spids: [3693]
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$ch'))}
              arms: [
                (case_arm
                  pat_list: [{(DQ (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>))}]
                  action: [(C {<read_string>})]
                  spids: [3708 3711 3717 -1]
                )
                (case_arm
                  pat_list: [{(DQ <'('>)}]
                  action: [(C {<read_list>})]
                  spids: [3720 3723 3729 -1]
                )
                (case_arm
                  pat_list: [{(DQ <'['>)}]
                  action: [(C {<read_vector>})]
                  spids: [3732 3735 3741 -1]
                )
                (case_arm
                  pat_list: [{(DQ <'\''>)}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<lisp_read>})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:read1)
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                              spids: [3754]
                            )
                          ]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<cons>} {(DQ ($ Id.VSub_DollarName '$read1'))} 
                          {($ Id.VSub_DollarName '$NIL')}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:read2)
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                              spids: [3770]
                            )
                          ]
                        )
                      ]
                    )
                    (C {<cons>} {($ Id.VSub_DollarName '$QUOTE')} {(DQ ($ Id.VSub_DollarName '$read2'))})
                  ]
                  spids: [3744 3747 3785 -1]
                )
                (case_arm
                  pat_list: [{(DQ <';'>)}]
                  action: [(C {<skip_comment>}) (C {<lisp_read>})]
                  spids: [3788 3791 3800 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [(C {($ Id.VSub_DollarName '$_ungetc')}) (C {<read_token>})]
                  spids: [3803 3804 -1 3813]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: string_list
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'c='> (DQ ($ Id.VSub_Number '$1'))} {<ret>})
            (C {<shift>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {(DQ ($ Id.VSub_Number '$1'))}
                                  right: {(DQ )}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<cons>} {($ Id.VSub_DollarName '$c')} {($ Id.VSub_DollarName '$NIL')})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:ret)
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                              spids: [3865]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [3838 3854]
                )
              ]
              else_action: [
                (C {<string_list>} {($ Id.VSub_Star '$*')})
                (command.AndOr
                  ops: [Id.Op_DAmp]
                  children: [
                    (C {<cons>} {($ Id.VSub_DollarName '$c')} {($ Id.VSub_DollarName '$r')})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:ret)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                          spids: [3887]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:r)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$ret'))}
                  spids: [3896]
                )
              ]
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:printing)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [3907]
        )
      ]
    )
    (command.ShFunction
      name: escape_str
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<i>} {<c>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:r)
                  op: assign_op.Equal
                  rhs: {(DQ )}
                  spids: [3924]
                )
              ]
            )
            (command.ForExpr
              init: 
                (arith_expr.BinaryAssign
                  op_id: Id.Arith_Equal
                  left: <Id.Lit_ArithVarLike i>
                  right: {<Id.Lit_Digits 0>}
                )
              cond: 
                (arith_expr.Binary
                  op_id: Id.Arith_Less
                  left: <Id.Lit_ArithVarLike i>
                  right: {(braced_var_sub token:<Id.VSub_Number 1> prefix_op:(Id.VSub_Pound))}
                )
              update: (arith_expr.UnaryAssign op_id:Id.Node_PostDPlus child:<Id.Lit_ArithVarLike i>)
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:c)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Number 1>
                                  suffix_op: 
                                    (suffix_op.Slice
                                      begin: {($ Id.VSub_DollarName '$i')}
                                      length: {<Id.Lit_Digits 1>}
                                    )
                                )
                              )
                            }
                          spids: [3956]
                        )
                      ]
                    )
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName '$c'))}
                      arms: [
                        (case_arm
                          pat_list: [{(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:r)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ (${ Id.VSub_Name r) 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\\\'>
                                        ) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>)
                                      )
                                    }
                                  spids: [3980]
                                )
                              ]
                            )
                          ]
                          spids: [3977 3978 3989 -1]
                        )
                        (case_arm
                          pat_list: [{(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\\'>)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:r)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ (${ Id.VSub_Name r) 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\\\'>
                                        ) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\\'>)
                                      )
                                    }
                                  spids: [3995]
                                )
                              ]
                            )
                          ]
                          spids: [3992 3993 4004 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:r)
                                  op: assign_op.Equal
                                  rhs: {(DQ (${ Id.VSub_Name r) (${ Id.VSub_Name c))}
                                  spids: [4010]
                                )
                              ]
                            )
                          ]
                          spids: [4007 4008 -1 4021]
                        )
                      ]
                    )
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: str_arr
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'ret='> (DQ <'['>)})
            (C {<count_array>} {(DQ ($ Id.VSub_Number '$1'))})
            (C {<local>} {<Id.Lit_VarLike 'len='> ($ Id.VSub_DollarName '$r')})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DParen
                              child: 
                                (arith_expr.Binary
                                  op_id: Id.Arith_NEqual
                                  left: {<Id.Lit_Digits 0>}
                                  right: <Id.Lit_ArithVarLike len>
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<vget>} {($ Id.VSub_Number '$1')} {<0>})
                    (C {<str>} {(DQ ($ Id.VSub_DollarName '$r'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:ret)
                          op: assign_op.Equal
                          rhs: {(DQ (${ Id.VSub_Name ret) (${ Id.VSub_Name r))}
                          spids: [4088]
                        )
                      ]
                    )
                    (command.ForExpr
                      init: 
                        (arith_expr.BinaryAssign
                          op_id: Id.Arith_Equal
                          left: <Id.Lit_ArithVarLike i>
                          right: {<Id.Lit_Digits 1>}
                        )
                      cond: 
                        (arith_expr.Binary
                          op_id: Id.Arith_Less
                          left: <Id.Lit_ArithVarLike i>
                          right: {($ Id.VSub_DollarName '$len')}
                        )
                      update: 
                        (arith_expr.UnaryAssign
                          op_id: Id.Node_PostDPlus
                          child: <Id.Lit_ArithVarLike i>
                        )
                      body: 
                        (command.DoGroup
                          children: [
                            (C {<vget>} {($ Id.VSub_Number '$1')} {($ Id.VSub_DollarName '$i')})
                            (C {<str>} {(DQ ($ Id.VSub_DollarName '$r'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:ret)
                                  op: assign_op.Equal
                                  rhs: {(DQ (${ Id.VSub_Name ret) <' '> (${ Id.VSub_Name r))}
                                  spids: [4139]
                                )
                              ]
                            )
                          ]
                        )
                    )
                  ]
                  spids: [4057 4071]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:r)
                  op: assign_op.Equal
                  rhs: {(DQ (${ Id.VSub_Name ret) <']'>)}
                  spids: [4157]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: str_list
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'lst='> (DQ ($ Id.VSub_Number '$1'))})
            (C {<local>} {<ret>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Name car>
                                          bracket_op: 
                                            (bracket_op.ArrayIndex
                                              expr: {($ Id.VSub_DollarName '$lst')}
                                            )
                                        )
                                      )
                                    }
                                  right: {($ Id.VSub_DollarName '$FN')}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<strip_tag>} {(DQ ($ Id.VSub_DollarName '$lst'))})
                        (C {<printf>} {<-v>} {<r>} {(SQ <'#<function:%s>'>)} 
                          {(DQ ($ Id.VSub_DollarName '$r'))}
                        )
                      ]
                    )
                  ]
                  spids: [4188 4208]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:ret)
                      op: assign_op.Equal
                      rhs: {(DQ <'('>)}
                      spids: [4237]
                    )
                  ]
                )
                (C {<str>} 
                  {
                    (DQ 
                      (braced_var_sub
                        token: <Id.VSub_Name car>
                        bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName '$lst')})
                      )
                    )
                  }
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:ret)
                      op: assign_op.Equal
                      rhs: {(DQ (${ Id.VSub_Name ret) (${ Id.VSub_Name r))}
                      spids: [4255]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:lst)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ 
                            (braced_var_sub
                              token: <Id.VSub_Name cdr>
                              bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName '$lst')})
                            )
                          )
                        }
                      spids: [4266]
                    )
                  ]
                )
                (command.WhileUntil
                  keyword: <Id.KW_While while>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<typeP>} {(DQ ($ Id.VSub_DollarName '$lst'))} {<cons>})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  body: 
                    (command.DoGroup
                      children: [
                        (C {<str>} 
                          {
                            (DQ 
                              (braced_var_sub
                                token: <Id.VSub_Name car>
                                bracket_op: 
                                  (bracket_op.ArrayIndex
                                    expr: {($ Id.VSub_DollarName '$lst')}
                                  )
                              )
                            )
                          }
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:ret)
                              op: assign_op.Equal
                              rhs: {(DQ (${ Id.VSub_Name ret) <' '> (${ Id.VSub_Name r))}
                              spids: [4304]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:lst)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ 
                                    (braced_var_sub
                                      token: <Id.VSub_Name cdr>
                                      bracket_op: 
                                        (bracket_op.ArrayIndex
                                          expr: {($ Id.VSub_DollarName '$lst')}
                                        )
                                    )
                                  )
                                }
                              spids: [4316]
                            )
                          ]
                        )
                      ]
                    )
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobNEqual
                                      left: {(DQ ($ Id.VSub_DollarName '$lst'))}
                                      right: {($ Id.VSub_DollarName '$NIL')}
                                    )
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      action: [
                        (C {<str>} {(DQ ($ Id.VSub_DollarName '$lst'))})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:ret)
                              op: assign_op.Equal
                              rhs: {(DQ (${ Id.VSub_Name ret) <' . '> (${ Id.VSub_Name r))}
                              spids: [4355]
                            )
                          ]
                        )
                      ]
                      spids: [4330 4345]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:r)
                      op: assign_op.Equal
                      rhs: {(DQ (${ Id.VSub_Name ret) <')'>)}
                      spids: [4370]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: str
      body: 
        (BraceGroup
          children: [
            (C {<type>} {(DQ ($ Id.VSub_Number '$1'))})
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$r'))}
              arms: [
                (case_arm
                  pat_list: [{<integer>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<strip_tag>} {(DQ ($ Id.VSub_Number '$1'))})
                        (C {<printf>} {<-v>} {<r>} {(SQ <'%d'>)} {(DQ ($ Id.VSub_DollarName '$r'))})
                      ]
                    )
                  ]
                  spids: [4407 4408 4432 -1]
                )
                (case_arm
                  pat_list: [{<cons>}]
                  action: [(C {<str_list>} {(DQ ($ Id.VSub_Number '$1'))})]
                  spids: [4435 4436 4444 -1]
                )
                (case_arm
                  pat_list: [{<vector>}]
                  action: [(C {<str_arr>} {(DQ ($ Id.VSub_Number '$1'))})]
                  spids: [4447 4448 4456 -1]
                )
                (case_arm
                  pat_list: [{<symbol>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<strip_tag>} {(DQ ($ Id.VSub_Number '$1'))})
                        (C {<printf>} {<-v>} {<r>} {(SQ <'%s'>)} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (command.Pipeline
                                    children: [
                                      (C {<echo>} 
                                        {
                                          (DQ 
                                            (braced_var_sub
                                              token: <Id.VSub_Name symbols>
                                              bracket_op: 
                                                (bracket_op.ArrayIndex
                                                  expr: {($ Id.VSub_DollarName '$r')}
                                                )
                                            )
                                          )
                                        }
                                      )
                                      (C {<tr>} {($ Id.VSub_DollarName '$pb_star')} {(DQ <'*'>)})
                                    ]
                                    negated: F
                                  )
                              )
                            )
                          }
                        )
                      ]
                    )
                  ]
                  spids: [4459 4460 4505 -1]
                )
                (case_arm
                  pat_list: [{<keyword>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<strip_tag>} {(DQ ($ Id.VSub_Number '$1'))})
                        (C {<printf>} {<-v>} {<r>} {(SQ <':%s'>)} {(DQ ($ Id.VSub_DollarName '$r'))})
                      ]
                    )
                  ]
                  spids: [4508 4509 4533 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_n
                                          child: {($ Id.VSub_DollarName '$printing')}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<escape_str>} {(DQ ($ Id.VSub_Number '$1'))})
                            (C {<printf>} {<-v>} {<r>} {(SQ <'"%s"'>)} {(DQ ($ Id.VSub_DollarName '$r'))})
                          ]
                          spids: [4540 4551]
                        )
                      ]
                      else_action: [
                        (C {<printf>} {<-v>} {<r>} {(SQ <'%s'>)} {(DQ ($ Id.VSub_Number '$1'))})
                      ]
                    )
                  ]
                  spids: [4536 4537 4597 -1]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: prn
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:printing)
                  op: assign_op.Equal
                  rhs: {<1>}
                  spids: [4612]
                )
              ]
            )
            (C {<str>} {(DQ ($ Id.VSub_Number '$1'))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:printing)
                  op: assign_op.Equal
                  rhs: (word.Empty)
                  spids: [4623]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [(C {<printf>} {(SQ <'%s'>)} {(DQ ($ Id.VSub_DollarName '$r'))}) (C {<echo>})]
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:frame_ptr)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [4647]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:stack_ptr)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [4650]
        )
      ]
    )
    (C {<declare>} {<-a>} {<stack>})
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<intern_symbol>} {(SQ <'&'>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:AMP)
              op: assign_op.Equal
              rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
              spids: [4669]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<intern_symbol>} {(SQ <nil>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:NIL)
              op: assign_op.Equal
              rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
              spids: [4682]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<intern_symbol>} {(SQ <t>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:T)
              op: assign_op.Equal
              rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
              spids: [4695]
            )
          ]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.IndexedName name:global_bindings index:{($ Id.VSub_DollarName '$NIL')})
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$NIL'))}
          spids: [4700]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.IndexedName name:global_bindings index:{($ Id.VSub_DollarName '$T')})
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$T'))}
          spids: [4709]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.IndexedName name:car index:{($ Id.VSub_DollarName '$NIL')})
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$NIL'))}
          spids: [4718]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.IndexedName name:cdr index:{($ Id.VSub_DollarName '$NIL')})
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$NIL'))}
          spids: [4727]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<new_array>})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:EMPTY)
              op: assign_op.Equal
              rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
              spids: [4741]
            )
          ]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:current_env)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$NIL'))}
          spids: [4747]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<intern_symbol>} {(SQ <quote>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:QUOTE)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [4761]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<intern_symbol>} {(SQ <fn>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:FN)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [4772]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<intern_symbol>} {(SQ <if>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:IF)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [4783]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<intern_symbol>} {(SQ <'set!'>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:SET_BANG)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [4794]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<intern_symbol>} {(SQ <def>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:DEF)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [4805]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<intern_symbol>} {(SQ <do>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:DO)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [4816]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<intern_symbol>} {(SQ <recur>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:RECUR)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [4827]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<intern_symbol>} {(SQ <binding>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:BINDING)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [4838]
            )
          ]
        )
      ]
    )
    (C {<declare>} {<-A>} {<specials>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.IndexedName name:specials index:{($ Id.VSub_DollarName '$QUOTE')})
          op: assign_op.Equal
          rhs: {<1>}
          spids: [4849]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.IndexedName name:specials index:{($ Id.VSub_DollarName '$FN')})
          op: assign_op.Equal
          rhs: {<1>}
          spids: [4856]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.IndexedName name:specials index:{($ Id.VSub_DollarName '$IF')})
          op: assign_op.Equal
          rhs: {<1>}
          spids: [4863]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.IndexedName name:specials index:{($ Id.VSub_DollarName '$SET_BANG')})
          op: assign_op.Equal
          rhs: {<1>}
          spids: [4870]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.IndexedName name:specials index:{($ Id.VSub_DollarName '$DEF')})
          op: assign_op.Equal
          rhs: {<1>}
          spids: [4877]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.IndexedName name:specials index:{($ Id.VSub_DollarName '$DO')})
          op: assign_op.Equal
          rhs: {<1>}
          spids: [4884]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.IndexedName name:specials index:{($ Id.VSub_DollarName '$RECUR')})
          op: assign_op.Equal
          rhs: {<1>}
          spids: [4891]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.IndexedName name:specials index:{($ Id.VSub_DollarName '$BINDING')})
          op: assign_op.Equal
          rhs: {<1>}
          spids: [4898]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <'eq?'>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:EQ)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [4914]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <'nil?'>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:NILP)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [4925]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <car>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:CAR)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [4936]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <cdr>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:CDR)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [4947]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <cons>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:CONS)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [4958]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <list>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:LIST)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [4969]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <vector>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:VECTOR)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [4980]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <keyword>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:KEYWORD)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [4991]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <eval>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:EVAL)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5002]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <apply>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:APPLY)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5013]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <read>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:READ)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5024]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <'+'>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:ADD)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5035]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <->)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:SUB)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5046]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(DQ ($ Id.VSub_DollarName '$pb_star'))})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:MUL)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5057]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <'/'>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:DIV)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5068]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <mod>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:MOD)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5079]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <'<'>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:LT)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5090]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <'>'>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:GT)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5101]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <'cons?'>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:CONSP)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5112]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <'symbol?'>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:SYMBOLP)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5123]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <'number?'>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:NUMBERP)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5134]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <'string?'>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:STRINGP)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5145]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <'fn?'>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:FNP)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5156]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <gensym>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:GENSYM)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5167]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <random>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:RAND)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5178]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <exit>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:EXIT)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5189]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <println>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:PRINTLN)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5200]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <sh>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:SH)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5211]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <'sh!'>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:SH_BANG)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5222]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <load-file>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:LOAD_FILE)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5233]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <gc>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:GC)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5244]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <error>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:ERROR)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5255]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <type>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:TYPE)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5266]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <str>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:STR)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5277]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <split>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:SPLIT)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5288]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<defprim>} {(SQ <getenv>)})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:GETENV)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$r')}
              spids: [5299]
            )
          ]
        )
      ]
    )
    (command.ShFunction
      name: eval_args
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'args='> (DQ ($ Id.VSub_Number '$1'))})
            (C {<type>} {(DQ ($ Id.VSub_DollarName '$args'))})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {(DQ ($ Id.VSub_DollarName '$r'))}
                                  right: {<cons>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.WhileUntil
                      keyword: <Id.KW_While while>
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobNEqual
                                      left: {(DQ ($ Id.VSub_DollarName '$args'))}
                                      right: {($ Id.VSub_DollarName '$NIL')}
                                    )
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      body: 
                        (command.DoGroup
                          children: [
                            (C {<lisp_eval>} 
                              {
                                (DQ 
                                  (braced_var_sub
                                    token: <Id.VSub_Name car>
                                    bracket_op: 
                                      (bracket_op.ArrayIndex
                                        expr: {($ Id.VSub_DollarName '$args')}
                                      )
                                  )
                                )
                              }
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.IndexedName
                                      name: stack
                                      index: 
                                        {
                                          (word_part.ArithSub
                                            anode: 
                                              (arith_expr.UnaryAssign
                                                op_id: Id.Node_PostDPlus
                                                child: <Id.Lit_ArithVarLike stack_ptr>
                                              )
                                          )
                                        }
                                    )
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                                  spids: [5373]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:args)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Name cdr>
                                          bracket_op: 
                                            (bracket_op.ArrayIndex
                                              expr: {($ Id.VSub_DollarName '$args')}
                                            )
                                        )
                                      )
                                    }
                                  spids: [5391]
                                )
                              ]
                            )
                          ]
                        )
                    )
                  ]
                  spids: [5325 5340]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {(DQ ($ Id.VSub_DollarName '$r'))}
                                  right: {<vector>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<count_array>} {(DQ ($ Id.VSub_DollarName '$args'))})
                    (C {<local>} {<i>} {<Id.Lit_VarLike 'len='> (DQ ($ Id.VSub_DollarName '$r'))})
                    (command.ForExpr
                      init: 
                        (arith_expr.BinaryAssign
                          op_id: Id.Arith_Equal
                          left: <Id.Lit_ArithVarLike i>
                          right: {<Id.Lit_Digits 0>}
                        )
                      cond: 
                        (arith_expr.Binary
                          op_id: Id.Arith_Less
                          left: <Id.Lit_ArithVarLike i>
                          right: <Id.Lit_ArithVarLike len>
                        )
                      update: 
                        (arith_expr.UnaryAssign
                          op_id: Id.Node_PostDPlus
                          child: <Id.Lit_ArithVarLike i>
                        )
                      body: 
                        (command.DoGroup
                          children: [
                            (C {<vget>} {(DQ ($ Id.VSub_DollarName '$args'))} 
                              {(DQ ($ Id.VSub_DollarName '$i'))}
                            )
                            (C {<lisp_eval>} {(DQ ($ Id.VSub_DollarName '$r'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.IndexedName
                                      name: stack
                                      index: 
                                        {
                                          (word_part.ArithSub
                                            anode: 
                                              (arith_expr.UnaryAssign
                                                op_id: Id.Node_PostDPlus
                                                child: <Id.Lit_ArithVarLike stack_ptr>
                                              )
                                          )
                                        }
                                    )
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                                  spids: [5480]
                                )
                              ]
                            )
                          ]
                        )
                    )
                  ]
                  spids: [5405 5420]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobNEqual
                                  left: {(DQ ($ Id.VSub_Number '$1'))}
                                  right: {(DQ ($ Id.VSub_DollarName '$NIL'))}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<str>} {(DQ ($ Id.VSub_DollarName '$args'))})
                    (C {<error>} {(DQ <'Unknown argument type: '> ($ Id.VSub_DollarName '$r'))})
                  ]
                  spids: [5501 5518]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: listify_args
      body: 
        (BraceGroup
          children: [
            (C {<local>} 
              {<Id.Lit_VarLike 'p='> 
                (word_part.ArithSub
                  anode: 
                    (arith_expr.Binary
                      op_id: Id.Arith_Minus
                      left: <Id.Lit_ArithVarLike stack_ptr>
                      right: {<Id.Lit_Digits 1>}
                    )
                )
              } {<Id.Lit_VarLike 'ret='> ($ Id.VSub_DollarName '$NIL')} {<stop>}
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DPipe]
              children: [
                (command.DBracket
                  expr: (bool_expr.Unary op_id:Id.BoolUnary_z child:{(DQ ($ Id.VSub_Number '$1'))})
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:stop)
                      op: assign_op.Equal
                      rhs: {($ Id.VSub_DollarName '$frame_ptr')}
                      spids: [5578]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:stop)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_Number '$1'))}
                      spids: [5583]
                    )
                  ]
                )
              ]
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.DParen
                          child: 
                            (arith_expr.Binary
                              op_id: Id.Arith_LessEqual
                              left: <Id.Lit_ArithVarLike stop>
                              right: <Id.Lit_ArithVarLike p>
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<cons>} 
                          {
                            (DQ 
                              (braced_var_sub
                                token: <Id.VSub_Name stack>
                                bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName '$p')})
                              )
                            )
                          } {(DQ ($ Id.VSub_DollarName '$ret'))}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:ret)
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                              spids: [5621]
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:p)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (word_part.ArithSub
                                anode: 
                                  (arith_expr.Binary
                                    op_id: Id.Arith_Minus
                                    left: <Id.Lit_ArithVarLike p>
                                    right: {<Id.Lit_Digits 1>}
                                  )
                              )
                            }
                          spids: [5627]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:r)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$ret'))}
                  spids: [5641]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: vectify_args
      body: 
        (BraceGroup
          children: [
            (C {<local>} 
              {<Id.Lit_VarLike 'stop='> 
                (word_part.ArithSub
                  anode: 
                    (arith_expr.Binary
                      op_id: Id.Arith_Minus
                      left: <Id.Lit_ArithVarLike stack_ptr>
                      right: {<Id.Lit_Digits 1>}
                    )
                )
              } {<ret>}
            )
            (C {<new_array>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:ret)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                  spids: [5674]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DPipe]
              children: [
                (command.DBracket
                  expr: (bool_expr.Unary op_id:Id.BoolUnary_z child:{(DQ ($ Id.VSub_Number '$1'))})
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:p)
                      op: assign_op.Equal
                      rhs: {($ Id.VSub_DollarName '$frame_ptr')}
                      spids: [5692]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:p)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_Number '$1'))}
                      spids: [5697]
                    )
                  ]
                )
              ]
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.DParen
                          child: 
                            (arith_expr.Binary
                              op_id: Id.Arith_LessEqual
                              left: <Id.Lit_ArithVarLike p>
                              right: <Id.Lit_ArithVarLike stop>
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (C {<append>} {(DQ ($ Id.VSub_DollarName '$ret'))} 
                      {
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name stack>
                            bracket_op: 
                              (bracket_op.ArrayIndex
                                expr: 
                                  {
                                    (word_part.ArithSub
                                      anode: 
                                        (arith_expr.UnaryAssign
                                          op_id: Id.Node_PostDPlus
                                          child: <Id.Lit_ArithVarLike p>
                                        )
                                    )
                                  }
                              )
                          )
                        )
                      }
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:r)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$ret'))}
                  spids: [5741]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: acons
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'key='> (DQ ($ Id.VSub_Number '$1'))} 
              {<Id.Lit_VarLike 'datum='> (DQ ($ Id.VSub_Number '$2'))} {<Id.Lit_VarLike 'a_list='> (DQ ($ Id.VSub_Number '$3'))}
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<cons>} {(DQ ($ Id.VSub_DollarName '$key'))} {(DQ ($ Id.VSub_DollarName '$datum'))})
                (C {<cons>} {(DQ ($ Id.VSub_DollarName '$r'))} {(DQ ($ Id.VSub_DollarName '$a_list'))})
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: aget
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'key='> (DQ ($ Id.VSub_Number '$1'))} 
              {<Id.Lit_VarLike 'a_list='> (DQ ($ Id.VSub_Number '$2'))}
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobNEqual
                              left: {(DQ ($ Id.VSub_DollarName '$a_list'))}
                              right: {($ Id.VSub_DollarName '$NIL')}
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Name car>
                                                  bracket_op: 
                                                    (bracket_op.ArrayIndex
                                                      expr: 
                                                        {
                                                          (braced_var_sub
                                                            token: <Id.VSub_Name car>
                                                            bracket_op: 
                                                              (bracket_op.ArrayIndex
                                                                expr: 
                                                                  {($ Id.VSub_DollarName '$a_list')}
                                                              )
                                                          )
                                                        }
                                                    )
                                                )
                                              )
                                            }
                                          right: {(DQ ($ Id.VSub_DollarName '$key'))}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:r)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (braced_var_sub
                                              token: <Id.VSub_Name cdr>
                                              bracket_op: 
                                                (bracket_op.ArrayIndex
                                                  expr: 
                                                    {
                                                      (braced_var_sub
                                                        token: <Id.VSub_Name car>
                                                        bracket_op: 
                                                          (bracket_op.ArrayIndex
                                                            expr: {($ Id.VSub_DollarName '$a_list')}
                                                          )
                                                      )
                                                    }
                                                )
                                            )
                                          )
                                        }
                                      spids: [5867]
                                    )
                                  ]
                                )
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Return return>
                                  arg_word: {<0>}
                                )
                              ]
                            )
                          ]
                          spids: [5837 5864]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:a_list)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name cdr>
                                  bracket_op: 
                                    (bracket_op.ArrayIndex
                                      expr: {($ Id.VSub_DollarName '$a_list')}
                                    )
                                )
                              )
                            }
                          spids: [5892]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:r)
                      op: assign_op.Equal
                      rhs: {($ Id.VSub_DollarName '$NIL')}
                      spids: [5906]
                    )
                  ]
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<1>}
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: analyze
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'fn='> (DQ ($ Id.VSub_Number '$1'))} 
              {<Id.Lit_VarLike 'body='> (DQ ($ Id.VSub_Number '$2'))} {<Id.Lit_VarLike 'env='> (DQ ($ Id.VSub_Number '$3'))}
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobNEqual
                              left: {(DQ ($ Id.VSub_DollarName '$body'))}
                              right: {(DQ ($ Id.VSub_DollarName '$NIL'))}
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (C {<type>} 
                      {
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name car>
                            bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName '$body')})
                          )
                        )
                      }
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$r'))}
                                          right: {<cons>}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.Case
                              to_match: 
                                {
                                  (DQ 
                                    (braced_var_sub
                                      token: <Id.VSub_Name car>
                                      bracket_op: 
                                        (bracket_op.ArrayIndex
                                          expr: 
                                            {
                                              (braced_var_sub
                                                token: <Id.VSub_Name car>
                                                bracket_op: 
                                                  (bracket_op.ArrayIndex
                                                    expr: {($ Id.VSub_DollarName '$body')}
                                                  )
                                              )
                                            }
                                        )
                                    )
                                  )
                                }
                              arms: [
                                (case_arm
                                  pat_list: [{($ Id.VSub_DollarName '$FN')}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: 
                                            (sh_lhs_expr.IndexedName
                                              name: environments
                                              index: 
                                                {
                                                  (DQ 
                                                    (braced_var_sub
                                                      token: <Id.VSub_Name car>
                                                      bracket_op: 
                                                        (bracket_op.ArrayIndex
                                                          expr: {($ Id.VSub_DollarName '$body')}
                                                        )
                                                    )
                                                  )
                                                }
                                            )
                                          op: assign_op.Equal
                                          rhs: {(DQ ($ Id.VSub_DollarName '$env'))}
                                          spids: [6015]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [6012 6013 6029 -1]
                                )
                                (case_arm
                                  pat_list: [{($ Id.VSub_DollarName '$RECUR')}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: 
                                            (sh_lhs_expr.IndexedName
                                              name: recur_fns
                                              index: 
                                                {
                                                  (DQ 
                                                    (braced_var_sub
                                                      token: <Id.VSub_Name car>
                                                      bracket_op: 
                                                        (bracket_op.ArrayIndex
                                                          expr: {($ Id.VSub_DollarName '$body')}
                                                        )
                                                    )
                                                  )
                                                }
                                            )
                                          op: assign_op.Equal
                                          rhs: {(DQ ($ Id.VSub_DollarName '$fn'))}
                                          spids: [6045]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: 
                                            (sh_lhs_expr.IndexedName
                                              name: recur_frames
                                              index: 
                                                {
                                                  (DQ 
                                                    (braced_var_sub
                                                      token: <Id.VSub_Name car>
                                                      bracket_op: 
                                                        (bracket_op.ArrayIndex
                                                          expr: {($ Id.VSub_DollarName '$body')}
                                                        )
                                                    )
                                                  )
                                                }
                                            )
                                          op: assign_op.Equal
                                          rhs: {(DQ ($ Id.VSub_DollarName '$frame_ptr'))}
                                          spids: [6069]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [6041 6042 6093 -1]
                                )
                                (case_arm
                                  pat_list: [{<Id.Lit_Star '*'>}]
                                  action: [
                                    (C {<analyze>} {(DQ ($ Id.VSub_DollarName '$fn'))} 
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            token: <Id.VSub_Name car>
                                            bracket_op: 
                                              (bracket_op.ArrayIndex
                                                expr: {($ Id.VSub_DollarName '$body')}
                                              )
                                          )
                                        )
                                      } {(DQ ($ Id.VSub_DollarName '$env'))}
                                    )
                                  ]
                                  spids: [6096 6097 6118 -1]
                                )
                              ]
                            )
                          ]
                          spids: [5975 5990]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:body)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name cdr>
                                  bracket_op: 
                                    (bracket_op.ArrayIndex
                                      expr: {($ Id.VSub_DollarName '$body')}
                                    )
                                )
                              )
                            }
                          spids: [6127]
                        )
                      ]
                    )
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: copy_list
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'lst='> (DQ ($ Id.VSub_Number '$1'))} 
              {<Id.Lit_VarLike 'copy='> (DQ ($ Id.VSub_DollarName '$NIL'))} {<Id.Lit_VarLike 'prev='> (DQ ($ Id.VSub_DollarName '$NIL'))} 
              {<Id.Lit_VarLike 'curr='> (DQ ($ Id.VSub_DollarName '$NIL'))}
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobNEqual
                              left: {(DQ ($ Id.VSub_DollarName '$lst'))}
                              right: {(DQ ($ Id.VSub_DollarName '$NIL'))}
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<cons>} 
                          {
                            (DQ 
                              (braced_var_sub
                                token: <Id.VSub_Name car>
                                bracket_op: 
                                  (bracket_op.ArrayIndex
                                    expr: {($ Id.VSub_DollarName '$lst')}
                                  )
                              )
                            )
                          } {(DQ ($ Id.VSub_DollarName '$NIL'))}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:curr)
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                              spids: [6210]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$copy'))}
                                          right: {(DQ ($ Id.VSub_DollarName '$NIL'))}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:copy)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName '$curr'))}
                                  spids: [6236]
                                )
                              ]
                            )
                          ]
                          spids: [6216 6233]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: 
                                (sh_lhs_expr.IndexedName
                                  name: cdr
                                  index: {(DQ ($ Id.VSub_DollarName '$prev'))}
                                )
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_DollarName '$curr'))}
                              spids: [6245]
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:prev)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$curr'))}
                          spids: [6262]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:lst)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name cdr>
                                  bracket_op: 
                                    (bracket_op.ArrayIndex
                                      expr: {($ Id.VSub_DollarName '$lst')}
                                    )
                                )
                              )
                            }
                          spids: [6268]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:r)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$copy'))}
                  spids: [6282]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: apply_user
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'fn='> (DQ ($ Id.VSub_Number '$1'))})
            (C {<local>} 
              {<Id.Lit_VarLike 'body='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name cdr>
                    bracket_op: 
                      (bracket_op.ArrayIndex
                        expr: 
                          {
                            (braced_var_sub
                              token: <Id.VSub_Name cdr>
                              bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName '$fn')})
                            )
                          }
                      )
                  )
                )
              }
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'params='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name car>
                    bracket_op: 
                      (bracket_op.ArrayIndex
                        expr: 
                          {
                            (braced_var_sub
                              token: <Id.VSub_Name cdr>
                              bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName '$fn')})
                            )
                          }
                      )
                  )
                )
              }
            )
            (C {<local>} {<Id.Lit_VarLike 'p='> (DQ ($ Id.VSub_DollarName '$frame_ptr'))})
            (C {<local>} {<Id.Lit_VarLike 'ret='> (DQ ($ Id.VSub_DollarName '$NIL'))})
            (C {<local>} {<old_env>})
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DPipe]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Unary
                      op_id: Id.BoolUnary_z
                      child: 
                        {
                          (DQ 
                            (braced_var_sub
                              token: <Id.VSub_Name environments>
                              bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName '$fn')})
                            )
                          )
                        }
                    )
                )
                (C {<local>} {<Id.Lit_VarLike 'env='> ($ Id.VSub_DollarName '$NIL')})
                (C {<local>} 
                  {<Id.Lit_VarLike 'env='> 
                    (DQ 
                      (braced_var_sub
                        token: <Id.VSub_Name environments>
                        bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName '$fn')})
                      )
                    )
                  }
                )
              ]
            )
            (C {<type>} {(DQ ($ Id.VSub_DollarName '$params'))})
            (C {<local>} {<Id.Lit_VarLike 'ptype='> (DQ ($ Id.VSub_DollarName '$r'))})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {(DQ ($ Id.VSub_DollarName '$ptype'))}
                                  right: {(DQ <cons>)}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.WhileUntil
                      keyword: <Id.KW_While while>
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.LogicalAnd
                                      left: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobNEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$params'))}
                                          right: {($ Id.VSub_DollarName '$NIL')}
                                        )
                                      right: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobNEqual
                                          left: 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Name car>
                                                  bracket_op: 
                                                    (bracket_op.ArrayIndex
                                                      expr: {($ Id.VSub_DollarName '$params')}
                                                    )
                                                )
                                              )
                                            }
                                          right: {($ Id.VSub_DollarName '$AMP')}
                                        )
                                    )
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      body: 
                        (command.DoGroup
                          children: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<acons>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name car>
                                        bracket_op: 
                                          (bracket_op.ArrayIndex
                                            expr: {($ Id.VSub_DollarName '$params')}
                                          )
                                      )
                                    )
                                  } 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name stack>
                                        bracket_op: 
                                          (bracket_op.ArrayIndex
                                            expr: 
                                              {
                                                (word_part.ArithSub
                                                  anode: 
                                                    (arith_expr.UnaryAssign
                                                      op_id: Id.Node_PostDPlus
                                                      child: <Id.Lit_ArithVarLike p>
                                                    )
                                                )
                                              }
                                          )
                                      )
                                    )
                                  } {(DQ ($ Id.VSub_DollarName '$env'))}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:env)
                                      op: assign_op.Equal
                                      rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                                      spids: [6499]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:params)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Name cdr>
                                          bracket_op: 
                                            (bracket_op.ArrayIndex
                                              expr: {($ Id.VSub_DollarName '$params')}
                                            )
                                        )
                                      )
                                    }
                                  spids: [6505]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Name car>
                                                  bracket_op: 
                                                    (bracket_op.ArrayIndex
                                                      expr: {($ Id.VSub_DollarName '$params')}
                                                    )
                                                )
                                              )
                                            }
                                          right: {($ Id.VSub_DollarName '$AMP')}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<listify_args>} {(DQ ($ Id.VSub_DollarName '$p'))})
                                (C {<local>} {<Id.Lit_VarLike 'more='> (DQ ($ Id.VSub_DollarName '$r'))})
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<acons>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name car>
                                        bracket_op: 
                                          (bracket_op.ArrayIndex
                                            expr: 
                                              {
                                                (braced_var_sub
                                                  token: <Id.VSub_Name cdr>
                                                  bracket_op: 
                                                    (bracket_op.ArrayIndex
                                                      expr: {($ Id.VSub_DollarName '$params')}
                                                    )
                                                )
                                              }
                                          )
                                      )
                                    )
                                  } {(DQ ($ Id.VSub_DollarName '$more'))} {(DQ ($ Id.VSub_DollarName '$env'))}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:env)
                                      op: assign_op.Equal
                                      rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                                      spids: [6584]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                          spids: [6519 6539]
                        )
                      ]
                    )
                  ]
                  spids: [6416 6433]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {(DQ ($ Id.VSub_DollarName '$ptype'))}
                                  right: {(DQ <vector>)}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<local>} {<Id.Lit_VarLike 'i='> <1>} {<len>})
                    (C {<count_array>} {(DQ ($ Id.VSub_DollarName '$params'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:len)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                          spids: [6628]
                        )
                      ]
                    )
                    (C {<vget>} {($ Id.VSub_DollarName '$params')} {<0>})
                    (command.WhileUntil
                      keyword: <Id.KW_While while>
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (command.DParen
                                      child: 
                                        (arith_expr.Binary
                                          op_id: Id.Arith_LessEqual
                                          left: <Id.Lit_ArithVarLike i>
                                          right: <Id.Lit_ArithVarLike len>
                                        )
                                    )
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobNEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$r'))}
                                          right: {($ Id.VSub_DollarName '$AMP')}
                                        )
                                    )
                                  ]
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      body: 
                        (command.DoGroup
                          children: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<acons>} {(DQ ($ Id.VSub_DollarName '$r'))} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name stack>
                                        bracket_op: 
                                          (bracket_op.ArrayIndex
                                            expr: 
                                              {
                                                (word_part.ArithSub
                                                  anode: 
                                                    (arith_expr.UnaryAssign
                                                      op_id: Id.Node_PostDPlus
                                                      child: <Id.Lit_ArithVarLike p>
                                                    )
                                                )
                                              }
                                          )
                                      )
                                    )
                                  } {(DQ ($ Id.VSub_DollarName '$env'))}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:env)
                                      op: assign_op.Equal
                                      rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                                      spids: [6695]
                                    )
                                  ]
                                )
                              ]
                            )
                            (C {<vget>} {($ Id.VSub_DollarName '$params')} 
                              {
                                (word_part.ArithSub
                                  anode: 
                                    (arith_expr.UnaryAssign
                                      op_id: Id.Node_PostDPlus
                                      child: <Id.Lit_ArithVarLike i>
                                    )
                                )
                              }
                            )
                          ]
                        )
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$r'))}
                                          right: {(DQ ($ Id.VSub_DollarName '$AMP'))}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<listify_args>} {(DQ ($ Id.VSub_DollarName '$p'))})
                                (C {<local>} {<Id.Lit_VarLike 'more='> (DQ ($ Id.VSub_DollarName '$r'))})
                              ]
                            )
                            (C {<vget>} {($ Id.VSub_DollarName '$params')} {($ Id.VSub_DollarName '$i')})
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<acons>} {(DQ ($ Id.VSub_DollarName '$r'))} 
                                  {(DQ ($ Id.VSub_DollarName '$more'))} {(DQ ($ Id.VSub_DollarName '$env'))}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:env)
                                      op: assign_op.Equal
                                      rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                                      spids: [6774]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                          spids: [6715 6732]
                        )
                      ]
                    )
                  ]
                  spids: [6593 6610]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobNEqual
                                  left: {(DQ ($ Id.VSub_DollarName '$params'))}
                                  right: {($ Id.VSub_DollarName '$NIL')}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<error>} 
                      {(DQ <'Illegal type ('> (${ Id.VSub_Name ptype) <') for params in function'>)}
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<1>}
                    )
                  ]
                  spids: [6783 6798]
                )
              ]
            )
            (C {<analyze>} {(DQ ($ Id.VSub_DollarName '$fn'))} {(DQ ($ Id.VSub_DollarName '$body'))} 
              {(DQ ($ Id.VSub_DollarName '$env'))}
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:old_env)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$current_env'))}
                  spids: [6838]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:current_env)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$env'))}
                  spids: [6844]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<do_>} {(DQ ($ Id.VSub_DollarName '$body'))})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:ret)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                      spids: [6858]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:current_env)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$old_env'))}
                  spids: [6864]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:r)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$ret'))}
                  spids: [6870]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: eval_file
      body: 
        (BraceGroup
          children: [
            (C {<strmap_file>} {(DQ ($ Id.VSub_Number '$1'))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_getc)
                  op: assign_op.Equal
                  rhs: {<strmap_getc>}
                  spids: [6892]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_ungetc)
                  op: assign_op.Equal
                  rhs: {<strmap_ungetc>}
                  spids: [6896]
                )
              ]
            )
            (C {<lisp_read>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_getc)
                  op: assign_op.Equal
                  rhs: {<getc>}
                  spids: [6903]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_ungetc)
                  op: assign_op.Equal
                  rhs: {<ungetc>}
                  spids: [6907]
                )
              ]
            )
            (C {<protect>} {(DQ ($ Id.VSub_DollarName '$r'))})
            (C {<lisp_eval>} {(DQ ($ Id.VSub_DollarName '$r'))})
            (C {<unprotect>})
          ]
        )
    )
    (command.ShFunction
      name: check_numbers
      body: 
        (BraceGroup
          children: [
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_n
                              child: {(DQ ($ Id.VSub_Number '$1'))}
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.Pipeline
                                      children: [
                                        (C {<typeP>} {(DQ ($ Id.VSub_Number '$1'))} {<integer>})
                                      ]
                                      negated: T
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<str>} {(DQ ($ Id.VSub_Number '$1'))})
                            (C {<error>} 
                              {(DQ <'\''> ($ Id.VSub_DollarName '$r') <'\' is not a number'>)}
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<1>}
                            )
                          ]
                          spids: [6953 6967]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: rev_str
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<i>} {<Id.Lit_VarLike 'rev='> (DQ )})
            (command.ForExpr
              init: 
                (arith_expr.BinaryAssign
                  op_id: Id.Arith_Equal
                  left: <Id.Lit_ArithVarLike i>
                  right: {<Id.Lit_Digits 0>}
                )
              cond: 
                (arith_expr.Binary
                  op_id: Id.Arith_Less
                  left: <Id.Lit_ArithVarLike i>
                  right: {(braced_var_sub token:<Id.VSub_Number 1> prefix_op:(Id.VSub_Pound))}
                )
              update: (arith_expr.UnaryAssign op_id:Id.Node_PostDPlus child:<Id.Lit_ArithVarLike i>)
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:rev)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Number 1>
                                  suffix_op: 
                                    (suffix_op.Slice
                                      begin: {($ Id.VSub_DollarName '$i')}
                                      length: {<Id.Lit_Digits 1>}
                                    )
                                ) (${ Id.VSub_Name rev)
                              )
                            }
                          spids: [7045]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:r)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$rev'))}
                  spids: [7063]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: apply_primitive
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'primitive='> (DQ ($ Id.VSub_Number '$1'))})
            (C {<local>} 
              {<Id.Lit_VarLike 'arg0='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name stack>
                    bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName '$frame_ptr')})
                  )
                )
              }
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'arg1='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name stack>
                    bracket_op: 
                      (bracket_op.ArrayIndex
                        expr: 
                          {
                            (word_part.ArithSub
                              anode: 
                                (arith_expr.Binary
                                  op_id: Id.Arith_Plus
                                  left: <Id.Lit_ArithVarLike frame_ptr>
                                  right: {<Id.Lit_Digits 1>}
                                )
                            )
                          }
                      )
                  )
                )
              }
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'arg2='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name stack>
                    bracket_op: 
                      (bracket_op.ArrayIndex
                        expr: 
                          {
                            (word_part.ArithSub
                              anode: 
                                (arith_expr.Binary
                                  op_id: Id.Arith_Plus
                                  left: <Id.Lit_ArithVarLike frame_ptr>
                                  right: {<Id.Lit_Digits 2>}
                                )
                            )
                          }
                      )
                  )
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:r)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$NIL')}
                  spids: [7136]
                )
              ]
            )
            (command.Case
              to_match: {($ Id.VSub_DollarName '$primitive')}
              arms: [
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$EQ')}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {(DQ ($ Id.VSub_DollarName '$arg0'))}
                              right: {(DQ ($ Id.VSub_DollarName '$arg1'))}
                            )
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:r)
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_DollarName '$T'))}
                              spids: [7166]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [7147 7148 7171 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$NILP')}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {(DQ ($ Id.VSub_DollarName '$arg0'))}
                              right: {($ Id.VSub_DollarName '$NIL')}
                            )
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:r)
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_DollarName '$T'))}
                              spids: [7191]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [7174 7175 7196 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$CAR')}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:r)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name car>
                                  bracket_op: 
                                    (bracket_op.ArrayIndex
                                      expr: {($ Id.VSub_DollarName '$arg0')}
                                    )
                                )
                              )
                            }
                          spids: [7202]
                        )
                      ]
                    )
                  ]
                  spids: [7199 7200 7212 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$CDR')}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:r)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name cdr>
                                  bracket_op: 
                                    (bracket_op.ArrayIndex
                                      expr: {($ Id.VSub_DollarName '$arg0')}
                                    )
                                )
                              )
                            }
                          spids: [7218]
                        )
                      ]
                    )
                  ]
                  spids: [7215 7216 7228 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$CONS')}]
                  action: [
                    (C {<cons>} {(DQ ($ Id.VSub_DollarName '$arg0'))} 
                      {(DQ ($ Id.VSub_DollarName '$arg1'))}
                    )
                  ]
                  spids: [7231 7232 7244 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$LIST')}]
                  action: [(C {<listify_args>})]
                  spids: [7247 7248 7252 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$VECTOR')}]
                  action: [(C {<vectify_args>})]
                  spids: [7255 7256 7260 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$KEYWORD')}]
                  action: [
                    (C {<type>} {(DQ ($ Id.VSub_DollarName '$arg0'))})
                    (command.Case
                      to_match: {($ Id.VSub_DollarName '$r')}
                      arms: [
                        (case_arm
                          pat_list: [{<string>}]
                          action: [(C {<make_keyword>} {(DQ ($ Id.VSub_DollarName '$arg0'))})]
                          spids: [7281 7282 7290 -1]
                        )
                        (case_arm
                          pat_list: [{<keyword>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:r)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName '$arg0'))}
                                  spids: [7296]
                                )
                              ]
                            )
                          ]
                          spids: [7293 7294 7301 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (C {<strip_tag>} {(DQ ($ Id.VSub_DollarName '$arg0'))})
                            (C {<error>} 
                              {(DQ <'Unable to make keyword from: '> ($ Id.VSub_DollarName '$r'))}
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:r)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName '$NIL'))}
                                  spids: [7323]
                                )
                              ]
                            )
                          ]
                          spids: [7304 7305 -1 7329]
                        )
                      ]
                    )
                  ]
                  spids: [7263 7264 7332 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$STR')}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<listify_args>})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:strs)
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                              spids: [7343]
                            )
                          ]
                        )
                      ]
                    )
                    (C {<local>} {<Id.Lit_VarLike 'ret='> (DQ )})
                    (command.WhileUntil
                      keyword: <Id.KW_While while>
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobNEqual
                                      left: {(DQ ($ Id.VSub_DollarName '$strs'))}
                                      right: {(DQ ($ Id.VSub_DollarName '$NIL'))}
                                    )
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      body: 
                        (command.DoGroup
                          children: [
                            (C {<str>} 
                              {
                                (DQ 
                                  (braced_var_sub
                                    token: <Id.VSub_Name car>
                                    bracket_op: 
                                      (bracket_op.ArrayIndex
                                        expr: {($ Id.VSub_DollarName '$strs')}
                                      )
                                  )
                                )
                              }
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:ret)
                                  op: assign_op.Equal
                                  rhs: {(DQ (${ Id.VSub_Name ret) ($ Id.VSub_DollarName '$r'))}
                                  spids: [7388]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:strs)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Name cdr>
                                          bracket_op: 
                                            (bracket_op.ArrayIndex
                                              expr: {($ Id.VSub_DollarName '$strs')}
                                            )
                                        )
                                      )
                                    }
                                  spids: [7397]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:r)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$ret'))}
                          spids: [7411]
                        )
                      ]
                    )
                  ]
                  spids: [7335 7336 7417 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$SPLIT')}]
                  action: [
                    (C {<local>} {<i>} {<Id.Lit_VarLike 'ret='> (DQ ($ Id.VSub_DollarName '$NIL'))} 
                      {<Id.Lit_VarLike 'last='> <0>}
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<rev_str>} {(DQ ($ Id.VSub_DollarName '$arg1'))})
                        (C {<local>} {<Id.Lit_VarLike 'rev='> (DQ ($ Id.VSub_DollarName '$r'))})
                      ]
                    )
                    (command.ForExpr
                      init: 
                        (arith_expr.BinaryAssign
                          op_id: Id.Arith_Equal
                          left: <Id.Lit_ArithVarLike i>
                          right: {<Id.Lit_Digits 0>}
                        )
                      cond: 
                        (arith_expr.Binary
                          op_id: Id.Arith_Less
                          left: <Id.Lit_ArithVarLike i>
                          right: {(braced_var_sub token:<Id.VSub_Name rev> prefix_op:(Id.VSub_Pound))}
                        )
                      update: 
                        (arith_expr.UnaryAssign
                          op_id: Id.Node_PostDPlus
                          child: <Id.Lit_ArithVarLike i>
                        )
                      body: 
                        (command.DoGroup
                          children: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_GlobDEqual
                                                  left: 
                                                    {
                                                      (DQ 
                                                        (braced_var_sub
                                                          token: <Id.VSub_Name rev>
                                                          suffix_op: 
                                                            (suffix_op.Slice
                                                              begin: {($ Id.VSub_DollarName '$i')}
                                                              length: {<Id.Lit_Digits 1>}
                                                            )
                                                        )
                                                      )
                                                    }
                                                  right: {(DQ ($ Id.VSub_DollarName '$arg0'))}
                                                )
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (C {<rev_str>} 
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            token: <Id.VSub_Name rev>
                                            suffix_op: 
                                              (suffix_op.Slice
                                                begin: {($ Id.VSub_DollarName '$last')}
                                                length: 
                                                  {
                                                    (word_part.ArithSub
                                                      anode: 
                                                        (arith_expr.Binary
                                                          op_id: Id.Arith_Minus
                                                          left: <Id.Lit_ArithVarLike i>
                                                          right: <Id.Lit_ArithVarLike last>
                                                        )
                                                    )
                                                  }
                                              )
                                          )
                                        )
                                      }
                                    )
                                    (command.AndOr
                                      ops: [Id.Op_DAmp]
                                      children: [
                                        (C {<cons>} {(DQ ($ Id.VSub_DollarName '$r'))} 
                                          {(DQ ($ Id.VSub_DollarName '$ret'))}
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:ret)
                                              op: assign_op.Equal
                                              rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                                              spids: [7538]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:last)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (word_part.ArithSub
                                                  anode: 
                                                    (arith_expr.Binary
                                                      op_id: Id.Arith_Plus
                                                      left: <Id.Lit_ArithVarLike i>
                                                      right: {<Id.Lit_Digits 1>}
                                                    )
                                                )
                                              )
                                            }
                                          spids: [7544]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [7480 7503]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DParen
                                      child: 
                                        (arith_expr.Binary
                                          op_id: Id.Arith_NEqual
                                          left: <Id.Lit_ArithVarLike last>
                                          right: {<Id.Lit_Digits 0>}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<rev_str>} 
                              {
                                (DQ 
                                  (braced_var_sub
                                    token: <Id.VSub_Name rev>
                                    suffix_op: 
                                      (suffix_op.Slice
                                        begin: {($ Id.VSub_DollarName '$last')}
                                        length: 
                                          {
                                            (word_part.ArithSub
                                              anode: 
                                                (arith_expr.Binary
                                                  op_id: Id.Arith_Minus
                                                  left: 
                                                    {
                                                      (braced_var_sub
                                                        token: <Id.VSub_Name rev>
                                                        prefix_op: (Id.VSub_Pound)
                                                      )
                                                    }
                                                  right: <Id.Lit_ArithVarLike last>
                                                )
                                            )
                                          }
                                      )
                                  )
                                )
                              }
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<cons>} {(DQ ($ Id.VSub_DollarName '$r'))} 
                                  {(DQ ($ Id.VSub_DollarName '$ret'))}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:ret)
                                      op: assign_op.Equal
                                      rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                                      spids: [7613]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                          spids: [7563 7575]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:r)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$ret'))}
                          spids: [7622]
                        )
                      ]
                    )
                  ]
                  spids: [7420 7421 7628 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$GETENV')}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_n
                              child: {(DQ ($ Id.VSub_DollarName '$arg0'))}
                            )
                        )
                        (C {<eval>} 
                          {
                            (DQ <'r='> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                              (${ Id.VSub_Name arg0)
                            )
                          }
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_z
                              child: {(DQ ($ Id.VSub_DollarName '$r'))}
                            )
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:r)
                              op: assign_op.Equal
                              rhs: {($ Id.VSub_DollarName '$NIL')}
                              spids: [7670]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [7631 7632 7674 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$EVAL')}]
                  action: [(C {<lisp_eval>} {(DQ ($ Id.VSub_DollarName '$arg0'))})]
                  spids: [7677 7678 7686 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$READ')}]
                  action: [(C {<lisp_read>})]
                  spids: [7689 7690 7694 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$MOD')}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<check_numbers>} {(DQ ($ Id.VSub_DollarName '$arg0'))} 
                                      {(DQ ($ Id.VSub_DollarName '$arg1'))}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<strip_tag>} {(DQ ($ Id.VSub_DollarName '$arg0'))})
                                (C {<local>} {<Id.Lit_VarLike 'x='> (DQ ($ Id.VSub_DollarName '$r'))})
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<strip_tag>} {(DQ ($ Id.VSub_DollarName '$arg1'))})
                                (C {<local>} {<Id.Lit_VarLike 'y='> (DQ ($ Id.VSub_DollarName '$r'))})
                              ]
                            )
                            (C {<make_integer>} 
                              {
                                (word_part.ArithSub
                                  anode: 
                                    (arith_expr.Binary
                                      op_id: Id.Arith_Percent
                                      left: <Id.Lit_ArithVarLike x>
                                      right: <Id.Lit_ArithVarLike y>
                                    )
                                )
                              }
                            )
                          ]
                          spids: [7701 7715]
                        )
                      ]
                    )
                  ]
                  spids: [7697 7698 7765 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$LT')}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<check_numbers>} {(DQ ($ Id.VSub_DollarName '$arg0'))} 
                                      {(DQ ($ Id.VSub_DollarName '$arg1'))}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<strip_tag>} {(DQ ($ Id.VSub_DollarName '$arg0'))})
                                (C {<local>} {<Id.Lit_VarLike 'x='> (DQ ($ Id.VSub_DollarName '$r'))})
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<strip_tag>} {(DQ ($ Id.VSub_DollarName '$arg1'))})
                                (C {<local>} {<Id.Lit_VarLike 'y='> (DQ ($ Id.VSub_DollarName '$r'))})
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp Id.Op_DPipe]
                              children: [
                                (command.DParen
                                  child: 
                                    (arith_expr.Binary
                                      op_id: Id.Arith_Less
                                      left: <Id.Lit_ArithVarLike x>
                                      right: <Id.Lit_ArithVarLike y>
                                    )
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:r)
                                      op: assign_op.Equal
                                      rhs: {($ Id.VSub_DollarName '$T')}
                                      spids: [7832]
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:r)
                                      op: assign_op.Equal
                                      rhs: {($ Id.VSub_DollarName '$NIL')}
                                      spids: [7837]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                          spids: [7772 7786]
                        )
                      ]
                    )
                  ]
                  spids: [7768 7769 7844 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$GT')}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<check_numbers>} {(DQ ($ Id.VSub_DollarName '$arg0'))} 
                                      {(DQ ($ Id.VSub_DollarName '$arg1'))}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<strip_tag>} {(DQ ($ Id.VSub_DollarName '$arg0'))})
                                (C {<local>} {<Id.Lit_VarLike 'x='> (DQ ($ Id.VSub_DollarName '$r'))})
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<strip_tag>} {(DQ ($ Id.VSub_DollarName '$arg1'))})
                                (C {<local>} {<Id.Lit_VarLike 'y='> (DQ ($ Id.VSub_DollarName '$r'))})
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp Id.Op_DPipe]
                              children: [
                                (command.DParen
                                  child: 
                                    (arith_expr.Binary
                                      op_id: Id.Arith_Great
                                      left: <Id.Lit_ArithVarLike x>
                                      right: <Id.Lit_ArithVarLike y>
                                    )
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:r)
                                      op: assign_op.Equal
                                      rhs: {($ Id.VSub_DollarName '$T')}
                                      spids: [7911]
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:r)
                                      op: assign_op.Equal
                                      rhs: {($ Id.VSub_DollarName '$NIL')}
                                      spids: [7916]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                          spids: [7851 7865]
                        )
                      ]
                    )
                  ]
                  spids: [7847 7848 7923 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$CONSP')}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<typeP>} {(DQ ($ Id.VSub_DollarName '$arg0'))} {<cons>})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:r)
                              op: assign_op.Equal
                              rhs: {($ Id.VSub_DollarName '$T')}
                              spids: [7939]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [7926 7927 7942 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$SYMBOLP')}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DPipe]
                      children: [
                        (C {<typeP>} {(DQ ($ Id.VSub_DollarName '$arg0'))} {<symbol>})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:r)
                              op: assign_op.Equal
                              rhs: {($ Id.VSub_DollarName '$T')}
                              spids: [7958]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:r)
                              op: assign_op.Equal
                              rhs: {($ Id.VSub_DollarName '$NIL')}
                              spids: [7963]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [7945 7946 7966 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$NUMBERP')}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DPipe]
                      children: [
                        (C {<typeP>} {(DQ ($ Id.VSub_DollarName '$arg0'))} {<integer>})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:r)
                              op: assign_op.Equal
                              rhs: {($ Id.VSub_DollarName '$T')}
                              spids: [7982]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:r)
                              op: assign_op.Equal
                              rhs: {($ Id.VSub_DollarName '$NIL')}
                              spids: [7987]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [7969 7970 7990 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$STRINGP')}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DPipe]
                      children: [
                        (C {<typeP>} {(DQ ($ Id.VSub_DollarName '$arg0'))} {<string>})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:r)
                              op: assign_op.Equal
                              rhs: {($ Id.VSub_DollarName '$T')}
                              spids: [8006]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:r)
                              op: assign_op.Equal
                              rhs: {($ Id.VSub_DollarName '$NIL')}
                              spids: [8011]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [7993 7994 8014 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$FNP')}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DAmp]
                      children: [
                        (C {<typeP>} {(DQ ($ Id.VSub_DollarName '$arg0'))} {<cons>})
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: 
                                {
                                  (DQ 
                                    (braced_var_sub
                                      token: <Id.VSub_Name car>
                                      bracket_op: 
                                        (bracket_op.ArrayIndex
                                          expr: {($ Id.VSub_DollarName '$arg0')}
                                        )
                                    )
                                  )
                                }
                              right: {($ Id.VSub_DollarName '$FN')}
                            )
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:r)
                              op: assign_op.Equal
                              rhs: {($ Id.VSub_DollarName '$T')}
                              spids: [8049]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [8017 8018 8052 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$GC')}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<gc>})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:r)
                              op: assign_op.Equal
                              rhs: {($ Id.VSub_DollarName '$NIL')}
                              spids: [8062]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [8055 8056 8065 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$GENSYM')}]
                  action: [(C {<gensym>})]
                  spids: [8068 8069 8073 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$ADD')}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<check_numbers>} {(DQ ($ Id.VSub_DollarName '$arg0'))} 
                                      {(DQ ($ Id.VSub_DollarName '$arg1'))}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<strip_tag>} {(DQ ($ Id.VSub_DollarName '$arg0'))})
                                (C {<local>} {<Id.Lit_VarLike 'x='> (DQ ($ Id.VSub_DollarName '$r'))})
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<strip_tag>} {(DQ ($ Id.VSub_DollarName '$arg1'))})
                                (C {<local>} {<Id.Lit_VarLike 'y='> (DQ ($ Id.VSub_DollarName '$r'))})
                              ]
                            )
                            (C {<make_integer>} 
                              {
                                (word_part.ArithSub
                                  anode: 
                                    (arith_expr.Binary
                                      op_id: Id.Arith_Plus
                                      left: <Id.Lit_ArithVarLike x>
                                      right: <Id.Lit_ArithVarLike y>
                                    )
                                )
                              }
                            )
                          ]
                          spids: [8080 8094]
                        )
                      ]
                    )
                  ]
                  spids: [8076 8077 8144 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$SUB')}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<check_numbers>} {(DQ ($ Id.VSub_DollarName '$arg0'))} 
                                      {(DQ ($ Id.VSub_DollarName '$arg1'))}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<strip_tag>} {(DQ ($ Id.VSub_DollarName '$arg0'))})
                                (C {<local>} {<Id.Lit_VarLike 'x='> (DQ ($ Id.VSub_DollarName '$r'))})
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<strip_tag>} {(DQ ($ Id.VSub_DollarName '$arg1'))})
                                (C {<local>} {<Id.Lit_VarLike 'y='> (DQ ($ Id.VSub_DollarName '$r'))})
                              ]
                            )
                            (C {<make_integer>} 
                              {
                                (word_part.ArithSub
                                  anode: 
                                    (arith_expr.Binary
                                      op_id: Id.Arith_Minus
                                      left: <Id.Lit_ArithVarLike x>
                                      right: <Id.Lit_ArithVarLike y>
                                    )
                                )
                              }
                            )
                          ]
                          spids: [8151 8165]
                        )
                      ]
                    )
                  ]
                  spids: [8147 8148 8215 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$APPLY')}]
                  action: [
                    (C {<local>} 
                      {<Id.Lit_VarLike 'old_frame_ptr='> ($ Id.VSub_DollarName '$frame_ptr')}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:frame_ptr)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$stack_ptr')}
                          spids: [8228]
                        )
                      ]
                    )
                    (C {<type>} {(DQ ($ Id.VSub_DollarName '$arg1'))})
                    (command.Case
                      to_match: {($ Id.VSub_DollarName '$r')}
                      arms: [
                        (case_arm
                          pat_list: [{<cons>}]
                          action: [
                            (command.WhileUntil
                              keyword: <Id.KW_While while>
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (C {<typeP>} {(DQ ($ Id.VSub_DollarName '$arg1'))} {<cons>})
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: 
                                            (sh_lhs_expr.IndexedName
                                              name: stack
                                              index: 
                                                {
                                                  (word_part.ArithSub
                                                    anode: 
                                                      (arith_expr.UnaryAssign
                                                        op_id: Id.Node_PostDPlus
                                                        child: <Id.Lit_ArithVarLike stack_ptr>
                                                      )
                                                  )
                                                }
                                            )
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Name car>
                                                  bracket_op: 
                                                    (bracket_op.ArrayIndex
                                                      expr: {($ Id.VSub_DollarName '$arg1')}
                                                    )
                                                )
                                              )
                                            }
                                          spids: [8264]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:arg1)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Name cdr>
                                                  bracket_op: 
                                                    (bracket_op.ArrayIndex
                                                      expr: {($ Id.VSub_DollarName '$arg1')}
                                                    )
                                                )
                                              )
                                            }
                                          spids: [8287]
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobNEqual
                                      left: {($ Id.VSub_DollarName '$arg1')}
                                      right: {($ Id.VSub_DollarName '$NIL')}
                                    )
                                )
                                (C {<error>} {(DQ <'Bad argument to apply: not a proper list'>)})
                              ]
                            )
                          ]
                          spids: [8246 8247 8320 -1]
                        )
                        (case_arm
                          pat_list: [{<vector>}]
                          action: [
                            (C {<count_array>} {(DQ ($ Id.VSub_DollarName '$arg1'))})
                            (C {<local>} {<Id.Lit_VarLike 'len='> (DQ ($ Id.VSub_DollarName '$r'))})
                            (command.ForExpr
                              init: 
                                (arith_expr.BinaryAssign
                                  op_id: Id.Arith_Equal
                                  left: <Id.Lit_ArithVarLike i>
                                  right: {<Id.Lit_Digits 0>}
                                )
                              cond: 
                                (arith_expr.Binary
                                  op_id: Id.Arith_Less
                                  left: <Id.Lit_ArithVarLike i>
                                  right: <Id.Lit_ArithVarLike len>
                                )
                              update: 
                                (arith_expr.UnaryAssign
                                  op_id: Id.Node_PostDPlus
                                  child: <Id.Lit_ArithVarLike i>
                                )
                              body: 
                                (command.DoGroup
                                  children: [
                                    (C {<vget>} {(DQ ($ Id.VSub_DollarName '$arg1'))} 
                                      {(DQ ($ Id.VSub_DollarName '$i'))}
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: 
                                            (sh_lhs_expr.IndexedName
                                              name: stack
                                              index: 
                                                {
                                                  (word_part.ArithSub
                                                    anode: 
                                                      (arith_expr.UnaryAssign
                                                        op_id: Id.Node_PostDPlus
                                                        child: <Id.Lit_ArithVarLike stack_ptr>
                                                      )
                                                  )
                                                }
                                            )
                                          op: assign_op.Equal
                                          rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                                          spids: [8375]
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                          ]
                          spids: [8323 8324 8396 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [(C {<error>} {(DQ <'Bad argument to apply: not a list'>)})]
                          spids: [8399 8400 -1 8409]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: {(DQ ($ Id.VSub_DollarName '$e'))}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<apply>} {(DQ ($ Id.VSub_DollarName '$arg0'))})]
                          spids: [8412 8425]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:stack_ptr)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$frame_ptr')}
                          spids: [8438]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:frame_ptr)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$old_frame_ptr')}
                          spids: [8442]
                        )
                      ]
                    )
                  ]
                  spids: [8218 8219 8446 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$ERROR')}]
                  action: [
                    (command.Simple
                      words: [{<printf>} {(SQ <'lisp error: '>)}]
                      redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                      do_fork: T
                    )
                    (command.Simple
                      words: [{<prn>} {(DQ ($ Id.VSub_DollarName '$arg0'))}]
                      redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                      do_fork: T
                    )
                  ]
                  spids: [8449 8450 8473 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$TYPE')}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$arg0'))}
                                          right: {($ Id.VSub_DollarName '$NIL')}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:r)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName '$NIL')}
                                  spids: [8498]
                                )
                              ]
                            )
                          ]
                          spids: [8480 8495]
                        )
                      ]
                      else_action: [
                        (C {<type>} {(DQ ($ Id.VSub_DollarName '$arg0'))})
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (command.AndOr
                                          ops: [Id.Op_DAmp]
                                          children: [
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_GlobDEqual
                                                  left: {(DQ ($ Id.VSub_DollarName '$r'))}
                                                  right: {<cons>}
                                                )
                                            )
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_GlobDEqual
                                                  left: 
                                                    {
                                                      (DQ 
                                                        (braced_var_sub
                                                          token: <Id.VSub_Name car>
                                                          bracket_op: 
                                                            (bracket_op.ArrayIndex
                                                              expr: {($ Id.VSub_DollarName '$arg0')}
                                                            )
                                                        )
                                                      )
                                                    }
                                                  right: {($ Id.VSub_DollarName '$FN')}
                                                )
                                            )
                                          ]
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              action: [(C {<intern_symbol>} {(DQ <function>)})]
                              spids: [8512 8546]
                            )
                          ]
                          else_action: [(C {<intern_symbol>} {(DQ ($ Id.VSub_DollarName '$r'))})]
                        )
                      ]
                    )
                  ]
                  spids: [8476 8477 8572 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$MUL')}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<check_numbers>} {(DQ ($ Id.VSub_DollarName '$arg0'))} 
                                      {(DQ ($ Id.VSub_DollarName '$arg1'))}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<strip_tag>} {(DQ ($ Id.VSub_DollarName '$arg0'))})
                                (C {<local>} {<Id.Lit_VarLike 'x='> (DQ ($ Id.VSub_DollarName '$r'))})
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<strip_tag>} {(DQ ($ Id.VSub_DollarName '$arg1'))})
                                (C {<local>} {<Id.Lit_VarLike 'y='> (DQ ($ Id.VSub_DollarName '$r'))})
                              ]
                            )
                            (C {<make_integer>} 
                              {
                                (word_part.ArithSub
                                  anode: 
                                    (arith_expr.Binary
                                      op_id: Id.Arith_Star
                                      left: <Id.Lit_ArithVarLike x>
                                      right: <Id.Lit_ArithVarLike y>
                                    )
                                )
                              }
                            )
                          ]
                          spids: [8579 8593]
                        )
                      ]
                    )
                  ]
                  spids: [8575 8576 8643 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$DIV')}]
                  action: [
                    (C {<local>} {<x>} {<y>})
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<check_numbers>} {(DQ ($ Id.VSub_DollarName '$arg0'))} 
                                      {(DQ ($ Id.VSub_DollarName '$arg1'))}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<strip_tag>} {($ Id.VSub_DollarName '$arg0')})
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:x)
                                      op: assign_op.Equal
                                      rhs: {($ Id.VSub_DollarName '$r')}
                                      spids: [8680]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<strip_tag>} {($ Id.VSub_DollarName '$arg1')})
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:y)
                                      op: assign_op.Equal
                                      rhs: {($ Id.VSub_DollarName '$r')}
                                      spids: [8690]
                                    )
                                  ]
                                )
                              ]
                            )
                            (C {<make_integer>} 
                              {
                                (word_part.ArithSub
                                  anode: 
                                    (arith_expr.Binary
                                      op_id: Id.Arith_Slash
                                      left: <Id.Lit_ArithVarLike x>
                                      right: <Id.Lit_ArithVarLike y>
                                    )
                                )
                              }
                            )
                          ]
                          spids: [8657 8671]
                        )
                      ]
                    )
                  ]
                  spids: [8646 8647 8709 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$RAND')}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: (C {<check_numbers>} {(DQ ($ Id.VSub_DollarName '$arg0'))})
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<strip_tag>} {($ Id.VSub_DollarName '$arg0')})
                            (C {<make_integer>} 
                              {
                                (DQ 
                                  (word_part.ArithSub
                                    anode: 
                                      (arith_expr.Binary
                                        op_id: Id.Arith_Percent
                                        left: <Id.Lit_ArithVarLike RANDOM>
                                        right: <Id.Lit_ArithVarLike r>
                                      )
                                  )
                                )
                              }
                            )
                          ]
                          spids: [8716 8726]
                        )
                      ]
                    )
                  ]
                  spids: [8712 8713 8751 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$PRINTLN')}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<listify_args>})
                        (C {<local>} {<Id.Lit_VarLike 'to_print='> (DQ ($ Id.VSub_DollarName '$r'))})
                      ]
                    )
                    (command.WhileUntil
                      keyword: <Id.KW_While while>
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobNEqual
                                      left: {(DQ ($ Id.VSub_DollarName '$to_print'))}
                                      right: {(DQ ($ Id.VSub_DollarName '$NIL'))}
                                    )
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      body: 
                        (command.DoGroup
                          children: [
                            (C {<type>} 
                              {
                                (DQ 
                                  (braced_var_sub
                                    token: <Id.VSub_Name car>
                                    bracket_op: 
                                      (bracket_op.ArrayIndex
                                        expr: {($ Id.VSub_DollarName '$to_print')}
                                      )
                                  )
                                )
                              }
                            )
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_DollarName '$r'))}
                              arms: [
                                (case_arm
                                  pat_list: [{<string>}]
                                  action: [
                                    (C {<echo>} {<-e>} 
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            token: <Id.VSub_Name car>
                                            bracket_op: 
                                              (bracket_op.ArrayIndex
                                                expr: {($ Id.VSub_DollarName '$to_print')}
                                              )
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  spids: [8811 8812 8829 -1]
                                )
                                (case_arm
                                  pat_list: [{<Id.Lit_Star '*'>}]
                                  action: [
                                    (C {<prn>} 
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            token: <Id.VSub_Name car>
                                            bracket_op: 
                                              (bracket_op.ArrayIndex
                                                expr: {($ Id.VSub_DollarName '$to_print')}
                                              )
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  spids: [8832 8833 8847 -1]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:to_print)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Name cdr>
                                          bracket_op: 
                                            (bracket_op.ArrayIndex
                                              expr: {($ Id.VSub_DollarName '$to_print')}
                                            )
                                        )
                                      )
                                    }
                                  spids: [8853]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:r)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$NIL'))}
                          spids: [8867]
                        )
                      ]
                    )
                  ]
                  spids: [8754 8755 8873 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$SH')}]
                  action: [
                    (C {<local>} {<ret>})
                    (C {<eval>} 
                      {
                        (DQ <'ret='> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'('> 
                          (${ Id.VSub_Name arg0) <')'>
                        )
                      }
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:IFS)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (single_quoted
                                left: <Id.Left_DollarSingleQuote '$\''>
                                tokens: [<Id.Char_OneChar '\\n'>]
                                multiline: F
                              )
                            }
                          spids: [8898]
                        )
                      ]
                    )
                    (C {<string_list>} 
                      {
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: 
                            (command.ForEach
                              iter_name: i
                              iter_words: [{($ Id.VSub_DollarName '$ret')}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.Sentence
                                      child: (C {<echo>} {(DQ ($ Id.VSub_DollarName '$i'))})
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                            )
                        )
                      }
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:IFS)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$DEFAULT_IFS'))}
                          spids: [8929]
                        )
                      ]
                    )
                  ]
                  spids: [8876 8877 8935 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$SH_BANG')}]
                  action: [
                    (C {<eval>} {(DQ (${ Id.VSub_Name arg0))})
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DPipe]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {($ Id.VSub_QMark '$?')}
                              right: {<0>}
                            )
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:r)
                              op: assign_op.Equal
                              rhs: {($ Id.VSub_DollarName '$T')}
                              spids: [8963]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:r)
                              op: assign_op.Equal
                              rhs: {($ Id.VSub_DollarName '$NIL')}
                              spids: [8968]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [8938 8939 8972 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$LOAD_FILE')}]
                  action: [
                    (C {<local>} {<f>})
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_r
                                          child: {(${ Id.VSub_Name arg0)}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:f)
                                  op: assign_op.Equal
                                  rhs: {(DQ (${ Id.VSub_Name arg0))}
                                  spids: [9000]
                                )
                              ]
                            )
                          ]
                          spids: [8984 8997]
                        )
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_r
                                          child: {(DQ (${ Id.VSub_Name arg0) <.gk>)}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:f)
                                  op: assign_op.Equal
                                  rhs: {(DQ (${ Id.VSub_Name arg0) <.gk>)}
                                  spids: [9027]
                                )
                              ]
                            )
                          ]
                          spids: [9008 9024]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobNEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$f'))}
                                          right: {(DQ )}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<eval_file>} {(DQ ($ Id.VSub_DollarName '$f'))})]
                          spids: [9039 9055]
                        )
                      ]
                      else_action: [
                        (command.Simple
                          words: [{<echo>} {(DQ <'File not found: '> (${ Id.VSub_Name arg0))}]
                          redirects: [
                            (redir
                              op: <Id.Redir_GreatAnd '>&'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<2>}
                            )
                          ]
                          do_fork: T
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:r)
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_DollarName '$NIL'))}
                              spids: [9081]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [8975 8976 9090 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$EXIT')}]
                  action: [
                    (C {<strip_tag>} {($ Id.VSub_DollarName '$arg0')})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {(DQ ($ Id.VSub_DollarName '$r'))}
                    )
                  ]
                  spids: [9093 9094 9109 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<strip_tag>} {(DQ ($ Id.VSub_Number '$1'))})
                        (C {<error>} 
                          {
                            (DQ <'unknown primitive function type: '> 
                              (braced_var_sub
                                token: <Id.VSub_Name symbols>
                                bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName '$r')})
                              )
                            )
                          }
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<1>}
                    )
                  ]
                  spids: [9112 9113 -1 9141]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: apply
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Name car>
                                          bracket_op: 
                                            (bracket_op.ArrayIndex
                                              expr: {($ Id.VSub_Number '$1')}
                                            )
                                        )
                                      )
                                    }
                                  right: {(DQ ($ Id.VSub_DollarName '$FN'))}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<apply_user>} {(DQ ($ Id.VSub_Number '$1'))})]
                  spids: [9153 9175]
                )
              ]
              else_action: [(C {<apply_primitive>} {(DQ ($ Id.VSub_Number '$1'))})]
            )
          ]
        )
    )
    (command.ShFunction
      name: add_bindings
      body: 
        (BraceGroup
          children: [
            (C {<type>} {(DQ ($ Id.VSub_Number '$1'))})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {($ Id.VSub_DollarName '$r')}
                                  right: {<cons>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<local>} {<Id.Lit_VarLike 'pairs='> (DQ ($ Id.VSub_Number '$1'))} {<val>})
                    (command.WhileUntil
                      keyword: <Id.KW_While while>
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.LogicalAnd
                                      left: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobNEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$pairs'))}
                                          right: {($ Id.VSub_DollarName '$NIL')}
                                        )
                                      right: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobNEqual
                                          left: 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Name cdr>
                                                  bracket_op: 
                                                    (bracket_op.ArrayIndex
                                                      expr: {($ Id.VSub_DollarName '$pairs')}
                                                    )
                                                )
                                              )
                                            }
                                          right: {($ Id.VSub_DollarName '$NIL')}
                                        )
                                    )
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      body: 
                        (command.DoGroup
                          children: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<lisp_eval>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name car>
                                        bracket_op: 
                                          (bracket_op.ArrayIndex
                                            expr: 
                                              {
                                                (braced_var_sub
                                                  token: <Id.VSub_Name cdr>
                                                  bracket_op: 
                                                    (bracket_op.ArrayIndex
                                                      expr: {($ Id.VSub_DollarName '$pairs')}
                                                    )
                                                )
                                              }
                                          )
                                      )
                                    )
                                  }
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:val)
                                      op: assign_op.Equal
                                      rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                                      spids: [9291]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Unary
                                                  op_id: Id.BoolUnary_n
                                                  child: {(DQ ($ Id.VSub_DollarName '$e'))}
                                                )
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.Sentence
                                      child: 
                                        (command.ControlFlow
                                          token: <Id.ControlFlow_Return return>
                                          arg_word: {<1>}
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                  spids: [9297 9310]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<acons>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name car>
                                        bracket_op: 
                                          (bracket_op.ArrayIndex
                                            expr: {($ Id.VSub_DollarName '$pairs')}
                                          )
                                      )
                                    )
                                  } {(DQ ($ Id.VSub_DollarName '$val'))} {(DQ ($ Id.VSub_DollarName '$current_env'))}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:current_env)
                                      op: assign_op.Equal
                                      rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                                      spids: [9341]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:pairs)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Name cdr>
                                          bracket_op: 
                                            (bracket_op.ArrayIndex
                                              expr: 
                                                {
                                                  (braced_var_sub
                                                    token: <Id.VSub_Name cdr>
                                                    bracket_op: 
                                                      (bracket_op.ArrayIndex
                                                        expr: {($ Id.VSub_DollarName '$pairs')}
                                                      )
                                                  )
                                                }
                                            )
                                        )
                                      )
                                    }
                                  spids: [9347]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobNEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$pairs'))}
                                          right: {($ Id.VSub_DollarName '$NIL')}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<error>} 
                              {(DQ <'Bad bindings. Must be an even number of binding forms.'>)}
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<1>}
                            )
                          ]
                          spids: [9366 9381]
                        )
                      ]
                    )
                  ]
                  spids: [9214 9227]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {(DQ ($ Id.VSub_DollarName '$r'))}
                                  right: {<vector>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<count_array>} {(DQ ($ Id.VSub_Number '$1'))})
                    (C {<local>} {<i>} {<v>} {<Id.Lit_VarLike 'len='> (DQ ($ Id.VSub_DollarName '$r'))})
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DParen
                                      child: 
                                        (arith_expr.Binary
                                          op_id: Id.Arith_DEqual
                                          left: 
                                            (arith_expr.Binary
                                              op_id: Id.Arith_Percent
                                              left: <Id.Lit_ArithVarLike len>
                                              right: {<Id.Lit_Digits 2>}
                                            )
                                          right: {<Id.Lit_Digits 0>}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ForExpr
                              init: 
                                (arith_expr.BinaryAssign
                                  op_id: Id.Arith_Equal
                                  left: <Id.Lit_ArithVarLike i>
                                  right: {<Id.Lit_Digits 0>}
                                )
                              cond: 
                                (arith_expr.Binary
                                  op_id: Id.Arith_Less
                                  left: <Id.Lit_ArithVarLike i>
                                  right: <Id.Lit_ArithVarLike len>
                                )
                              body: 
                                (command.DoGroup
                                  children: [
                                    (C {<vget>} {(DQ ($ Id.VSub_Number '$1'))} 
                                      {
                                        (word_part.ArithSub
                                          anode: 
                                            (arith_expr.UnaryAssign
                                              op_id: Id.Node_PostDPlus
                                              child: <Id.Lit_ArithVarLike i>
                                            )
                                        )
                                      }
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:v)
                                          op: assign_op.Equal
                                          rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                                          spids: [9491]
                                        )
                                      ]
                                    )
                                    (C {<vget>} {(DQ ($ Id.VSub_Number '$1'))} 
                                      {
                                        (word_part.ArithSub
                                          anode: 
                                            (arith_expr.UnaryAssign
                                              op_id: Id.Node_PostDPlus
                                              child: <Id.Lit_ArithVarLike i>
                                            )
                                        )
                                      }
                                    )
                                    (C {<lisp_eval>} {(DQ ($ Id.VSub_DollarName '$r'))})
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (command.Sentence
                                                  child: 
                                                    (command.DBracket
                                                      expr: 
                                                        (bool_expr.Unary
                                                          op_id: Id.BoolUnary_n
                                                          child: {(DQ ($ Id.VSub_DollarName '$e'))}
                                                        )
                                                    )
                                                  terminator: <Id.Op_Semi _>
                                                )
                                              ]
                                            )
                                          action: [
                                            (command.Sentence
                                              child: 
                                                (command.ControlFlow
                                                  token: <Id.ControlFlow_Return return>
                                                  arg_word: {<1>}
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                          spids: [9517 9530]
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Id.Op_DAmp]
                                      children: [
                                        (C {<acons>} {(DQ ($ Id.VSub_DollarName '$v'))} 
                                          {(DQ ($ Id.VSub_DollarName '$r'))} {(DQ ($ Id.VSub_DollarName '$current_env'))}
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:current_env)
                                              op: assign_op.Equal
                                              rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                                              spids: [9556]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                          ]
                          spids: [9436 9454]
                        )
                      ]
                      else_action: [
                        (C {<error>} {(DQ <'Bad bindings. Must be an even number of binding forms.'>)})
                      ]
                    )
                  ]
                  spids: [9399 9414]
                )
              ]
              else_action: [(C {<error>} {(DQ <'bindings not available.'>)})]
            )
          ]
        )
    )
    (command.ShFunction
      name: do_
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'body='> (DQ ($ Id.VSub_Number '$1'))} 
              {<Id.Lit_VarLike 'result='> (DQ ($ Id.VSub_DollarName '$NIL'))}
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobNEqual
                              left: {(DQ ($ Id.VSub_DollarName '$body'))}
                              right: {($ Id.VSub_DollarName '$NIL')}
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<lisp_eval>} 
                          {
                            (DQ 
                              (braced_var_sub
                                token: <Id.VSub_Name car>
                                bracket_op: 
                                  (bracket_op.ArrayIndex
                                    expr: {($ Id.VSub_DollarName '$body')}
                                  )
                              )
                            )
                          }
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:result)
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                              spids: [9644]
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:body)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name cdr>
                                  bracket_op: 
                                    (bracket_op.ArrayIndex
                                      expr: {($ Id.VSub_DollarName '$body')}
                                    )
                                )
                              )
                            }
                          spids: [9650]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<typeP>} {(DQ ($ Id.VSub_DollarName '$result'))} {<cons>})
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobDEqual
                                      left: 
                                        {
                                          (DQ 
                                            (braced_var_sub
                                              token: <Id.VSub_Name car>
                                              bracket_op: 
                                                (bracket_op.ArrayIndex
                                                  expr: {($ Id.VSub_DollarName '$result')}
                                                )
                                            )
                                          )
                                        }
                                      right: {(DQ ($ Id.VSub_DollarName '$FN'))}
                                    )
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<copy_list>} {(DQ ($ Id.VSub_DollarName '$result'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: 
                            (sh_lhs_expr.IndexedName
                              name: environments
                              index: {(DQ ($ Id.VSub_DollarName '$r'))}
                            )
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$current_env'))}
                          spids: [9706]
                        )
                      ]
                    )
                  ]
                  spids: [9664 9696]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:r)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$result'))}
                      spids: [9723]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: eval_special
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'special='> (DQ ($ Id.VSub_Number '$1'))})
            (C {<local>} 
              {<Id.Lit_VarLike 'op='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name car>
                    bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_Number '$1')})
                  )
                )
              }
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'args='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name cdr>
                    bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_Number '$1')})
                  )
                )
              }
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'arg0='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name car>
                    bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName '$args')})
                  )
                )
              }
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'arg1='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name car>
                    bracket_op: 
                      (bracket_op.ArrayIndex
                        expr: 
                          {
                            (braced_var_sub
                              token: <Id.VSub_Name cdr>
                              bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName '$args')})
                            )
                          }
                      )
                  )
                )
              }
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'arg2='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name car>
                    bracket_op: 
                      (bracket_op.ArrayIndex
                        expr: 
                          {
                            (braced_var_sub
                              token: <Id.VSub_Name cdr>
                              bracket_op: 
                                (bracket_op.ArrayIndex
                                  expr: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name cdr>
                                        bracket_op: 
                                          (bracket_op.ArrayIndex
                                            expr: {($ Id.VSub_DollarName '$args')}
                                          )
                                      )
                                    }
                                )
                            )
                          }
                      )
                  )
                )
              }
            )
            (command.Case
              to_match: {($ Id.VSub_DollarName '$op')}
              arms: [
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$QUOTE')}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:r)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$arg0'))}
                          spids: [9839]
                        )
                      ]
                    )
                  ]
                  spids: [9836 9837 9844 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$DO')}]
                  action: [(C {<do_>} {($ Id.VSub_DollarName '$args')})]
                  spids: [9847 9848 9854 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$FN')}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:r)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$special')}
                          spids: [9860]
                        )
                      ]
                    )
                  ]
                  spids: [9857 9858 9863 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$IF')}]
                  action: [
                    (C {<lisp_eval>} {(DQ ($ Id.VSub_DollarName '$arg0'))})
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DPipe]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobNEqual
                              left: {(DQ ($ Id.VSub_DollarName '$r'))}
                              right: {(DQ ($ Id.VSub_DollarName '$NIL'))}
                            )
                        )
                        (C {<lisp_eval>} {(DQ ($ Id.VSub_DollarName '$arg1'))})
                        (C {<lisp_eval>} {(DQ ($ Id.VSub_DollarName '$arg2'))})
                      ]
                    )
                  ]
                  spids: [9866 9867 9908 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$SET_BANG')}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_n
                                          child: 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Name global_bindings>
                                                  bracket_op: 
                                                    (bracket_op.ArrayIndex
                                                      expr: {($ Id.VSub_DollarName '$arg0')}
                                                    )
                                                )
                                              )
                                            }
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<lisp_eval>} {(DQ ($ Id.VSub_DollarName '$arg1'))})
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: 
                                        (sh_lhs_expr.IndexedName
                                          name: global_bindings
                                          index: {($ Id.VSub_DollarName '$arg0')}
                                        )
                                      op: assign_op.Equal
                                      rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                                      spids: [9944]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                          spids: [9915 9933]
                        )
                      ]
                      else_action: [
                        (command.AndOr
                          ops: [Id.Op_DAmp]
                          children: [
                            (C {<strip_tag>} {(DQ ($ Id.VSub_DollarName '$arg0'))})
                            (C {<error>} 
                              {
                                (DQ <'unbound variable: '> 
                                  (braced_var_sub
                                    token: <Id.VSub_Name symbols>
                                    bracket_op: 
                                      (bracket_op.ArrayIndex
                                        expr: {($ Id.VSub_DollarName '$r')}
                                      )
                                  )
                                )
                              }
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [9911 9912 9981 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$RECUR')}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:frame_ptr)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name recur_frames>
                                  bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_Number '$1')})
                                )
                              )
                            }
                          spids: [9988]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:stack_ptr)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$frame_ptr')}
                          spids: [9999]
                        )
                      ]
                    )
                    (command.WhileUntil
                      keyword: <Id.KW_While while>
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobNEqual
                                      left: {(DQ ($ Id.VSub_DollarName '$args'))}
                                      right: {($ Id.VSub_DollarName '$NIL')}
                                    )
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      body: 
                        (command.DoGroup
                          children: [
                            (C {<lisp_eval>} 
                              {
                                (DQ 
                                  (braced_var_sub
                                    token: <Id.VSub_Name car>
                                    bracket_op: 
                                      (bracket_op.ArrayIndex
                                        expr: {($ Id.VSub_DollarName '$args')}
                                      )
                                  )
                                )
                              }
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.IndexedName
                                      name: stack
                                      index: 
                                        {
                                          (word_part.ArithSub
                                            anode: 
                                              (arith_expr.UnaryAssign
                                                op_id: Id.Node_PostDPlus
                                                child: <Id.Lit_ArithVarLike stack_ptr>
                                              )
                                          )
                                        }
                                    )
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                                  spids: [10033]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:args)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Name cdr>
                                          bracket_op: 
                                            (bracket_op.ArrayIndex
                                              expr: {($ Id.VSub_DollarName '$args')}
                                            )
                                        )
                                      )
                                    }
                                  spids: [10051]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:current_env)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name environments>
                                  bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_Number '$1')})
                                )
                              )
                            }
                          spids: [10065]
                        )
                      ]
                    )
                    (C {<apply_user>} 
                      {
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name recur_fns>
                            bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_Number '$1')})
                          )
                        )
                      }
                    )
                  ]
                  spids: [9984 9985 10088 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$DEF')}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<lisp_eval>} {(DQ ($ Id.VSub_DollarName '$arg1'))})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: 
                                (sh_lhs_expr.IndexedName
                                  name: global_bindings
                                  index: {(DQ ($ Id.VSub_DollarName '$arg0'))}
                                )
                              op: assign_op.Equal
                              rhs: {($ Id.VSub_DollarName '$r')}
                              spids: [10103]
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:r)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$arg0'))}
                          spids: [10115]
                        )
                      ]
                    )
                  ]
                  spids: [10091 10092 10121 -1]
                )
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$BINDING')}]
                  action: [
                    (C {<local>} 
                      {<Id.Lit_VarLike 'binding_body='> 
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name cdr>
                            bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName '$args')})
                          )
                        )
                      }
                    )
                    (C {<local>} 
                      {<Id.Lit_VarLike 'old_env='> (DQ ($ Id.VSub_DollarName '$current_env'))}
                    )
                    (C {<add_bindings>} {($ Id.VSub_DollarName '$arg0')})
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: {(DQ ($ Id.VSub_DollarName '$e'))}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<do_>} {($ Id.VSub_DollarName '$binding_body')})]
                          spids: [10154 10167]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:current_env)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$old_env'))}
                          spids: [10178]
                        )
                      ]
                    )
                  ]
                  spids: [10124 10125 10184 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (C {<strip_tag>} {($ Id.VSub_DollarName '$op')})
                    (C {<error>} 
                      {
                        (DQ <'eval_special: unknown form: '> 
                          (braced_var_sub
                            token: <Id.VSub_Name symbols>
                            bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName '$r')})
                          )
                        )
                      }
                    )
                  ]
                  spids: [10187 10188 -1 10209]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: eval_function
      body: 
        (BraceGroup
          children: [
            (C {<local>} 
              {<Id.Lit_VarLike 'op='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name car>
                    bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_Number '$1')})
                  )
                )
              } {<eval_op>}
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'args='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name cdr>
                    bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_Number '$1')})
                  )
                )
              }
            )
            (C {<local>} {<Id.Lit_VarLike 'old_frame_ptr='> ($ Id.VSub_DollarName '$frame_ptr')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:frame_ptr)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$stack_ptr')}
                  spids: [10255]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<lisp_eval>} {(DQ ($ Id.VSub_DollarName '$op'))})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:eval_op)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                      spids: [10267]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_z
                                  child: {(DQ ($ Id.VSub_DollarName '$e'))}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<protect>} {(DQ ($ Id.VSub_DollarName '$eval_op'))})
                    (C {<eval_args>} {(DQ ($ Id.VSub_DollarName '$args'))})
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: {(DQ ($ Id.VSub_DollarName '$e'))}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<apply>} {(DQ ($ Id.VSub_DollarName '$eval_op'))})]
                          spids: [10303 10316]
                        )
                      ]
                    )
                    (C {<unprotect>})
                  ]
                  spids: [10273 10286]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:stack_ptr)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$frame_ptr')}
                  spids: [10335]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:frame_ptr)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$old_frame_ptr')}
                  spids: [10339]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: lisp_eval
      body: 
        (BraceGroup
          children: [
            (C {<type>} {($ Id.VSub_Number '$1')})
            (command.Case
              to_match: {($ Id.VSub_DollarName '$r')}
              arms: [
                (case_arm
                  pat_list: [{<symbol>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {(DQ ($ Id.VSub_Number '$1'))}
                              right: {(DQ ($ Id.VSub_DollarName '$NIL'))}
                            )
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:r)
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_DollarName '$NIL'))}
                              spids: [10384]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {(DQ ($ Id.VSub_Number '$1'))}
                              right: {(DQ ($ Id.VSub_DollarName '$T'))}
                            )
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:r)
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_DollarName '$T'))}
                              spids: [10410]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<aget>} {(DQ ($ Id.VSub_Number '$1'))} 
                          {(DQ ($ Id.VSub_DollarName '$current_env'))}
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_n
                                          child: 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Name global_bindings>
                                                  bracket_op: 
                                                    (bracket_op.ArrayIndex
                                                      expr: {($ Id.VSub_Number '$1')}
                                                    )
                                                )
                                              )
                                            }
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:r)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Name global_bindings>
                                          bracket_op: 
                                            (bracket_op.ArrayIndex
                                              expr: {($ Id.VSub_Number '$1')}
                                            )
                                        )
                                      )
                                    }
                                  spids: [10456]
                                )
                              ]
                            )
                          ]
                          spids: [10435 10453]
                        )
                      ]
                      else_action: [
                        (command.AndOr
                          ops: [Id.Op_DAmp]
                          children: [
                            (C {<strip_tag>} {(DQ ($ Id.VSub_Number '$1'))})
                            (C {<error>} 
                              {
                                (DQ <'unable to resolve '> 
                                  (braced_var_sub
                                    token: <Id.VSub_Name symbols>
                                    bracket_op: 
                                      (bracket_op.ArrayIndex
                                        expr: {($ Id.VSub_DollarName '$r')}
                                      )
                                  )
                                )
                              }
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [10364 10365 10494 -1]
                )
                (case_arm
                  pat_list: [{<cons>}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_n
                                          child: 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Name specials>
                                                  bracket_op: 
                                                    (bracket_op.ArrayIndex
                                                      expr: 
                                                        {
                                                          (braced_var_sub
                                                            token: <Id.VSub_Name car>
                                                            bracket_op: 
                                                              (bracket_op.ArrayIndex
                                                                expr: {($ Id.VSub_Number '$1')}
                                                              )
                                                          )
                                                        }
                                                    )
                                                )
                                              )
                                            }
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<eval_special>} {(DQ ($ Id.VSub_Number '$1'))})]
                          spids: [10501 10524]
                        )
                      ]
                      else_action: [(C {<eval_function>} {(DQ ($ Id.VSub_Number '$1'))})]
                    )
                  ]
                  spids: [10497 10498 10547 -1]
                )
                (case_arm
                  pat_list: [{<vector>}]
                  action: [
                    (C {<local>} 
                      {<Id.Lit_VarLike 'old_frame_ptr='> ($ Id.VSub_DollarName '$frame_ptr')}
                    )
                    (C {<local>} 
                      {<Id.Lit_VarLike 'old_stack_ptr='> ($ Id.VSub_DollarName '$stack_ptr')}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:frame_ptr)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$stack_ptr')}
                          spids: [10566]
                        )
                      ]
                    )
                    (C {<eval_args>} {(DQ ($ Id.VSub_Number '$1'))})
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: {(DQ ($ Id.VSub_DollarName '$e'))}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<vectify_args>})]
                          spids: [10577 10590]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:stack_ptr)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$old_stack_ptr')}
                          spids: [10599]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:frame_ptr)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$old_frame_ptr')}
                          spids: [10603]
                        )
                      ]
                    )
                  ]
                  spids: [10550 10551 10607 -1]
                )
                (case_arm
                  pat_list: [{<integer>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:r)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_Number '$1')}
                          spids: [10613]
                        )
                      ]
                    )
                  ]
                  spids: [10610 10611 10616 -1]
                )
                (case_arm
                  pat_list: [{<string>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:r)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_Number '$1'))}
                          spids: [10622]
                        )
                      ]
                    )
                  ]
                  spids: [10619 10620 10627 -1]
                )
                (case_arm
                  pat_list: [{<keyword>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:r)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_Number '$1'))}
                          spids: [10633]
                        )
                      ]
                    )
                  ]
                  spids: [10630 10631 10638 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (C {<error>} {(DQ <'lisp_eval: unrecognized type'>)})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<1>}
                    )
                  ]
                  spids: [10641 10642 10657 -1]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: init_history
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<intern_symbol>} {(DQ (${ Id.VSub_Name pb_star) <1>)})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:hist1)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                      spids: [10687]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<intern_symbol>} {(DQ (${ Id.VSub_Name pb_star) <2>)})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:hist2)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                      spids: [10704]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<intern_symbol>} {(DQ (${ Id.VSub_Name pb_star) <3>)})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:hist3)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                      spids: [10721]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: 
                    (sh_lhs_expr.IndexedName
                      name: global_bindings
                      index: {(DQ ($ Id.VSub_DollarName '$hist1'))}
                    )
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$NIL'))}
                  spids: [10727]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: 
                    (sh_lhs_expr.IndexedName
                      name: global_bindings
                      index: {(DQ ($ Id.VSub_DollarName '$hist2'))}
                    )
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$NIL'))}
                  spids: [10741]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: 
                    (sh_lhs_expr.IndexedName
                      name: global_bindings
                      index: {(DQ ($ Id.VSub_DollarName '$hist3'))}
                    )
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$NIL'))}
                  spids: [10755]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: update_history
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: 
                    (sh_lhs_expr.IndexedName
                      name: global_bindings
                      index: {(DQ ($ Id.VSub_DollarName '$hist3'))}
                    )
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (braced_var_sub
                          token: <Id.VSub_Name global_bindings>
                          bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName '$hist2')})
                        )
                      )
                    }
                  spids: [10778]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: 
                    (sh_lhs_expr.IndexedName
                      name: global_bindings
                      index: {(DQ ($ Id.VSub_DollarName '$hist2'))}
                    )
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (braced_var_sub
                          token: <Id.VSub_Name global_bindings>
                          bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName '$hist1')})
                        )
                      )
                    }
                  spids: [10797]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: 
                    (sh_lhs_expr.IndexedName
                      name: global_bindings
                      index: {(DQ ($ Id.VSub_DollarName '$hist1'))}
                    )
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$r'))}
                  spids: [10816]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: repl
      body: 
        (BraceGroup
          children: [
            (C {<init_history>})
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [(command.Sentence child:(C {<true>}) terminator:<Id.Op_Semi _>)]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:e)
                          op: assign_op.Equal
                          rhs: (word.Empty)
                          spids: [10850]
                        )
                      ]
                    )
                    (C {<lisp_read>})
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_n
                              child: {(DQ ($ Id.VSub_DollarName '$e'))}
                            )
                        )
                        (command.Simple
                          words: [
                            {<printf>}
                            {
                              (DQ <'read error: '> ($ Id.VSub_DollarName '$e') 
                                <Id.Lit_BadBackslash '\\'> <n>
                              )
                            }
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_GreatAnd '>&'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<2>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                    )
                    (C {<protect>} {(DQ ($ Id.VSub_DollarName '$r'))})
                    (C {<lisp_eval>} {(DQ ($ Id.VSub_DollarName '$r'))})
                    (C {<update_history>})
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_n
                              child: {(DQ ($ Id.VSub_DollarName '$e'))}
                            )
                        )
                        (command.Simple
                          words: [
                            {<printf>}
                            {
                              (DQ <'eval error: '> ($ Id.VSub_DollarName '$e') 
                                <Id.Lit_BadBackslash '\\'> <n>
                              )
                            }
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_GreatAnd '>&'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<2>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                    )
                    (C {<prn>} {(DQ ($ Id.VSub_DollarName '$r'))})
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_n
                              child: {(DQ ($ Id.VSub_DollarName '$e'))}
                            )
                        )
                        (command.Simple
                          words: [
                            {<printf>}
                            {
                              (DQ <'print error: '> ($ Id.VSub_DollarName '$e') 
                                <Id.Lit_BadBackslash '\\'> <n>
                              )
                            }
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_GreatAnd '>&'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<2>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                    )
                    (C {<unprotect>})
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: eval_string
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'str='> (DQ ($ Id.VSub_Number '$1'))})
            (command.Simple
              words: [{<lisp_read>}]
              redirects: [
                (redir
                  op: <Id.Redir_TLess '<<<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: {(DQ <'(do '> ($ Id.VSub_DollarName '$str') <')'>)}
                )
              ]
              do_fork: T
            )
            (C {<protect>} {(DQ ($ Id.VSub_DollarName '$r'))})
            (C {<lisp_eval>} {(DQ ($ Id.VSub_DollarName '$r'))})
            (C {<unprotect>})
          ]
        )
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_Star '$*'))} {<Id.Lit_RBracket ']'>})
        (C {<repl>})
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:ARGV)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_Star '$*'))}
          spids: [11032]
        )
      ]
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: 
        (condition.Shell
          commands: [
            (command.Sentence
              child: (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Star '$*'))} {<Id.Lit_RBracket ']'>})
              terminator: <Id.Op_Semi _>
            )
          ]
        )
      body: 
        (command.DoGroup
          children: [
            (command.Sentence
              child: 
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:param)
                      op: assign_op.Equal
                      rhs: {($ Id.VSub_Number '$1')}
                      spids: [11054]
                    )
                  ]
                )
              terminator: <Id.Op_Semi _>
            )
            (command.Sentence child:(C {<shift>}) terminator:<Id.Op_Semi _>)
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:OPTARG)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [11061]
                )
              ]
            )
            (command.Case
              to_match: {($ Id.VSub_DollarName '$param')}
              arms: [
                (case_arm
                  pat_list: [{<-e>} {<--eval>}]
                  action: [
                    (command.Sentence
                      child: (C {<eval_string>} {(DQ ($ Id.VSub_DollarName '$OPTARG'))})
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobNEqual
                              left: {($ Id.VSub_DollarName '$r')}
                              right: {($ Id.VSub_DollarName '$NIL')}
                            )
                        )
                        (C {<prn>} {($ Id.VSub_DollarName '$r')})
                      ]
                    )
                  ]
                  spids: [11072 11075 11104 -1]
                )
                (case_arm
                  pat_list: [{<-l>} {<--load>}]
                  action: [
                    (command.Sentence
                      child: (C {<eval_file>} {(DQ ($ Id.VSub_DollarName '$OPTARG'))})
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobNEqual
                              left: {($ Id.VSub_DollarName '$r')}
                              right: {($ Id.VSub_DollarName '$NIL')}
                            )
                        )
                        (C {<prn>} {($ Id.VSub_DollarName '$r')})
                      ]
                    )
                  ]
                  spids: [11107 11110 11139 -1]
                )
                (case_arm pat_list:[{<-t>} {<--test>}] spids:[11142 11145 11147 -1])
                (case_arm
                  pat_list: [{<-r>} {<--repl>}]
                  action: [(C {<repl>})]
                  spids: [11150 11153 11157 -1]
                )
                (case_arm
                  pat_list: [{<-> <Id.Lit_Star '*'>}]
                  action: [(C {<usage>})]
                  spids: [11160 11162 11166 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_f
                              child: {(DQ ($ Id.VSub_DollarName '$param'))}
                            )
                        )
                        (C {<has_shebangP>} {(DQ ($ Id.VSub_DollarName '$param'))})
                        (C {<eval_file>} {(DQ ($ Id.VSub_DollarName '$param'))})
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobNEqual
                              left: {($ Id.VSub_DollarName '$r')}
                              right: {($ Id.VSub_DollarName '$NIL')}
                            )
                        )
                        (C {<prn>} {($ Id.VSub_DollarName '$r')})
                      ]
                    )
                  ]
                  spids: [11169 11170 11216 -1]
                )
              ]
            )
          ]
        )
    )
  ]
)