(command.CommandList
  children: [
    (command.CommandList
      children: [
        (command.Sentence child:(C {<typeset>} {<-a>} {<_Dbg_yn>}) terminator:<Id.Op_Semi _>)
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:_Dbg_yn)
              op: assign_op.Equal
              rhs: {(sh_array_literal left:<Id.Op_LParen _> words:[{(DQ <n>)} {(DQ <y>)}])}
              spids: [68]
            )
          ]
        )
      ]
    )
    (command.ShFunction
      name: _Dbg_copies
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:result)
                  op: assign_op.Equal
                  rhs: {(SQ )}
                  spids: [93]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DParen
                  child: 
                    (arith_expr.Binary
                      op_id: Id.Arith_Less
                      left: {($ Id.VSub_Pound '$#')}
                      right: {<Id.Lit_Digits 2>}
                    )
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<1>}
                )
              ]
            )
            (C {<typeset>} {<-r>} {<Id.Lit_VarLike 'string='> (DQ ($ Id.VSub_Number '$1'))})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<typeset>} {<-i>} {<Id.Lit_VarLike 'count='> ($ Id.VSub_Number '$2')})
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<2>}
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.DParen
                  child: 
                    (arith_expr.Binary
                      op_id: Id.Arith_Great
                      left: <Id.Lit_ArithVarLike count>
                      right: {<Id.Lit_Digits 0>}
                    )
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<3>}
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<builtin>} {<printf>} {<-v>} {<result>} {(DQ <'%'> (${ Id.VSub_Name count) <s>)} 
                  {(SQ <' '>)}
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<3>}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:result)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name result>
                        suffix_op: 
                          (suffix_op.PatSub
                            pat: {<' '>}
                            replace: {($ Id.VSub_DollarName '$string')}
                            replace_mode: Id.Lit_Slash
                          )
                      )
                    }
                  spids: [185]
                )
              ]
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_defined
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DParen
                  child: 
                    (arith_expr.Binary
                      op_id: Id.Arith_DEqual
                      left: {<Id.Lit_Digits 0>}
                      right: {($ Id.VSub_Pound '$#')}
                    )
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<1>}
                )
              ]
            )
            (command.Simple
              words: [{<typeset>} {<-p>} {(DQ ($ Id.VSub_Number '$1'))}]
              redirects: [
                (redir
                  op: <Id.Redir_AndGreat '&>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {<'/dev/null'>}
                )
              ]
              do_fork: T
            )
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_esc_dq
      body: 
        (BraceGroup
          children: [
            (C {<builtin>} {<printf>} {(DQ <'%q'> <Id.Lit_BadBackslash '\\'> <n>)} 
              {(DQ ($ Id.VSub_Number '$1'))}
            )
          ]
        )
    )
    (command.Sentence child:(C {<typeset>} {<-a>} {<_Dbg_eval_re>}) terminator:<Id.Op_Semi _>)
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:_Dbg_eval_re)
          op: assign_op.Equal
          rhs: 
            {
              (sh_array_literal
                left: <Id.Op_LParen _>
                words: [
                  {(SQ <'^[ \\t]*(if|elif)[ \\t]+([^;]*)((;[ \\t]*then?)?|$)'>)}
                  {(SQ <'^[ \\t]*return[ \\t]+(.*)$'>)}
                  {(SQ <'^[ \\t]*while[ \\t]+([^;]*)((;[ \\t]*do?)?|$)'>)}
                  {(SQ <'^[ \\t]*[A-Za-z_][A-Za-z_0-9_]*[+-]?=(.*$)'>)}
                  {
                    (DQ <'^[ '> <Id.Lit_BadBackslash '\\'> <'t]*[A-Za-z_][A-Za-z_0-9_]*'> 
                      <Id.Lit_BadBackslash '\\'> <'[[0-9]+'> <Id.Lit_BadBackslash '\\'> <'][+-]?=(.*'> 
                      (word_part.EscapedLiteral
                        token: <Id.Lit_EscapedChar '\\$'>
                      ) <')'>
                    )
                  }
                ]
              )
            }
          spids: [289]
        )
      ]
    )
    (command.ShFunction
      name: _Dbg_eval_extract_condition
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:orig)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number '$1'))}
                  spids: [347]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_EqualTilde
                                  left: {($ Id.VSub_DollarName '$orig')}
                                  right: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name _Dbg_eval_re>
                                        bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 0>})
                                      )
                                    }
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:extracted)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <Id.VSub_Name BASH_REMATCH>
                                bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 2>})
                              )
                            }
                          spids: [375]
                        )
                      ]
                    )
                  ]
                  spids: [353 372]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_EqualTilde
                                  left: {($ Id.VSub_DollarName '$orig')}
                                  right: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name _Dbg_eval_re>
                                        bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 1>})
                                      )
                                    }
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:extracted)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ <'echo '> 
                                (braced_var_sub
                                  token: <Id.VSub_Name BASH_REMATCH>
                                  bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 1>})
                                )
                              )
                            }
                          spids: [406]
                        )
                      ]
                    )
                  ]
                  spids: [384 403]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_EqualTilde
                                  left: {($ Id.VSub_DollarName '$orig')}
                                  right: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name _Dbg_eval_re>
                                        bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 2>})
                                      )
                                    }
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:extracted)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <Id.VSub_Name BASH_REMATCH>
                                bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 1>})
                              )
                            }
                          spids: [440]
                        )
                      ]
                    )
                  ]
                  spids: [418 437]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_EqualTilde
                                  left: {($ Id.VSub_DollarName '$orig')}
                                  right: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name _Dbg_eval_re>
                                        bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 3>})
                                      )
                                    }
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:extracted)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ <'echo '> 
                                (braced_var_sub
                                  token: <Id.VSub_Name BASH_REMATCH>
                                  bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 1>})
                                )
                              )
                            }
                          spids: [471]
                        )
                      ]
                    )
                  ]
                  spids: [449 468]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_EqualTilde
                                  left: {($ Id.VSub_DollarName '$orig')}
                                  right: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name _Dbg_eval_re>
                                        bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 4>})
                                      )
                                    }
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:extracted)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ <'echo '> 
                                (braced_var_sub
                                  token: <Id.VSub_Name BASH_REMATCH>
                                  bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 1>})
                                )
                              )
                            }
                          spids: [505]
                        )
                      ]
                    )
                  ]
                  spids: [483 502]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:extracted)
                      op: assign_op.Equal
                      rhs: {($ Id.VSub_DollarName '$orig')}
                      spids: [520]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_onoff
      body: 
        (BraceGroup
          children: [
            (C {<typeset>} {<Id.Lit_VarLike 'onoff='> (SQ <off.>)})
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DParen
                  child: 
                    (arith_expr.Binary
                      op_id: Id.Arith_NEqual
                      left: {($ Id.VSub_Number '$1')}
                      right: {<Id.Lit_Digits 0>}
                    )
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:onoff)
                      op: assign_op.Equal
                      rhs: {(SQ <on.>)}
                      spids: [563]
                    )
                  ]
                )
              ]
            )
            (C {<builtin>} {<echo>} {($ Id.VSub_DollarName '$onoff')})
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_set_dol_q
      body: 
        (BraceGroup
          children: [
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: 
                {
                  (braced_var_sub
                    token: <Id.VSub_Number 1>
                    suffix_op: 
                      (suffix_op.Unary
                        tok: <Id.VTest_ColonHyphen ':-'>
                        arg_word: {($ Id.VSub_DollarName '$_Dbg_debugged_exit_code')}
                      )
                  )
                }
            )
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_split
      body: 
        (BraceGroup
          children: [
            (C {<typeset>} {<Id.Lit_VarLike 'old_IFS='> ($ Id.VSub_DollarName '$IFS')})
            (C {<typeset>} 
              {<Id.Lit_VarLike 'new_ifs='> 
                (braced_var_sub
                  token: <Id.VSub_Number 1>
                  suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:{(SQ <' '>)})
                )
              }
            )
            (C {<shift>})
            (C {<typeset>} {<-r>} {<Id.Lit_VarLike 'text='> (DQ ($ Id.VSub_Star '$*'))})
            (C {<typeset>} {<-a>} {<array>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:IFS)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$new_ifs'))}
                  spids: [663]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:array)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (sh_array_literal
                        left: <Id.Op_LParen _>
                        words: [{($ Id.VSub_DollarName '$text')}]
                      )
                    }
                  spids: [669]
                )
              ]
            )
            (C {<echo>} 
              {
                (braced_var_sub
                  token: <Id.VSub_Name array>
                  bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:IFS)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$old_IFS')}
                  spids: [687]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_get_functions
      body: 
        (BraceGroup
          children: [
            (C {<typeset>} {<-i>} 
              {<Id.Lit_VarLike 'include_system='> 
                (braced_var_sub
                  token: <Id.VSub_Number 1>
                  suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:{<0>})
                )
              }
            )
            (C {<typeset>} 
              {<Id.Lit_VarLike 'pat='> 
                (braced_var_sub
                  token: <Id.VSub_Number 2>
                  suffix_op: 
                    (suffix_op.Unary
                      tok: <Id.VTest_ColonHyphen ':-'>
                      arg_word: {<.> <Id.Lit_Other '*'>}
                    )
                )
              }
            )
            (C {<typeset>} {<-a>} {<fns_a>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:fns_a)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (sh_array_literal
                        left: <Id.Op_LParen _>
                        words: [
                          {
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              child: (C {<declare>} {<-F>})
                            )
                          }
                        ]
                      )
                    }
                  spids: [742]
                )
              ]
            )
            (C {<typeset>} {<-a>} {<Id.Lit_VarLike 'ret_fns='> (sh_array_literal left:<Id.Op_LParen _>)})
            (C {<typeset>} {<-i>} {<i>})
            (command.Sentence
              child: (C {<typeset>} {<-i>} {<Id.Lit_VarLike 'invert='> <0>})
              terminator: <Id.Op_Semi _>
            )
            (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 '$pat')}
                                  right: {<Id.KW_Bang '!'> <Id.Lit_Other '*'>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:pat)
                          op: assign_op.Equal
                          rhs: 
                            {<Id.Lit_Pound '#'> <Id.Lit_LBrace '{'> ($ Id.VSub_DollarName '$pat') 
                              <Id.Lit_Pound '#'> <Id.KW_Bang '!'> <Id.Lit_RBrace '}'>
                            }
                          spids: [802]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:invert)
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [811]
                        )
                      ]
                    )
                  ]
                  spids: [780 795]
                )
              ]
            )
            (command.ForExpr
              init: 
                (arith_expr.BinaryAssign
                  op_id: Id.Arith_Equal
                  left: <Id.Lit_ArithVarLike i>
                  right: {<Id.Lit_Digits 2>}
                )
              cond: 
                (arith_expr.Binary
                  op_id: Id.Arith_Less
                  left: <Id.Lit_ArithVarLike i>
                  right: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name fns_a>
                        prefix_op: (Id.VSub_Pound)
                        bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                      )
                    }
                )
              update: 
                (arith_expr.BinaryAssign
                  op_id: Id.Arith_PlusEqual
                  left: <Id.Lit_ArithVarLike i>
                  right: {<Id.Lit_Digits 3>}
                )
              body: 
                (command.DoGroup
                  children: [
                    (C {<typeset>} 
                      {<Id.Lit_VarLike 'fn='> 
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name fns_a>
                            bracket_op: (bracket_op.ArrayIndex expr:{($ Id.VSub_DollarName '$i')})
                          )
                        )
                      }
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {($ Id.VSub_DollarName '$fn')}
                              right: {<_> <Id.Lit_Other '*'>}
                            )
                        )
                        (command.DParen
                          child: 
                            (arith_expr.Unary
                              op_id: Id.Arith_Bang
                              child: <Id.Lit_ArithVarLike include_system>
                            )
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Continue continue>
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_EqualTilde
                                          left: {($ Id.VSub_DollarName '$fn')}
                                          right: {($ Id.VSub_DollarName '$pat')}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobDEqual
                                      left: {($ Id.VSub_DollarName '$invert')}
                                      right: {<0>}
                                    )
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: 
                                        (sh_lhs_expr.IndexedName
                                          name: ret_fns
                                          index: 
                                            {
                                              (braced_var_sub
                                                token: <Id.VSub_Name ret_fns>
                                                prefix_op: (Id.VSub_Pound)
                                                bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                              )
                                            }
                                        )
                                      op: assign_op.Equal
                                      rhs: {($ Id.VSub_DollarName '$fn')}
                                      spids: [935]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                          spids: [906 920]
                        )
                      ]
                      else_action: [
                        (command.AndOr
                          ops: [Id.Op_DAmp]
                          children: [
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobNEqual
                                  left: {($ Id.VSub_DollarName '$invert')}
                                  right: {<0>}
                                )
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.IndexedName
                                      name: ret_fns
                                      index: 
                                        {
                                          (braced_var_sub
                                            token: <Id.VSub_Name ret_fns>
                                            prefix_op: (Id.VSub_Pound)
                                            bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                          )
                                        }
                                    )
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName '$fn')}
                                  spids: [970]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
            )
            (C {<echo>} 
              {
                (braced_var_sub
                  token: <Id.VSub_Name ret_fns>
                  bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                )
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_is_function
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DParen
                  child: 
                    (arith_expr.Binary
                      op_id: Id.Arith_DEqual
                      left: {<Id.Lit_Digits 0>}
                      right: {($ Id.VSub_Pound '$#')}
                    )
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<1>}
                )
              ]
            )
            (C {<typeset>} {<Id.Lit_VarLike 'needed_fn='> ($ Id.VSub_Number '$1')})
            (C {<typeset>} {<-i>} 
              {<Id.Lit_VarLike 'include_system='> 
                (braced_var_sub
                  token: <Id.VSub_Number 2>
                  suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:{<0>})
                )
              }
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_GlobDEqual
                      left: 
                        {
                          (braced_var_sub
                            token: <Id.VSub_Name needed_fn>
                            suffix_op: 
                              (suffix_op.Slice
                                begin: {<Id.Lit_Digits 0>}
                                length: {<Id.Lit_Digits 1>}
                              )
                          )
                        }
                      right: {(SQ <_>)}
                    )
                )
                (command.DParen
                  child: 
                    (arith_expr.Unary
                      op_id: Id.Arith_Bang
                      child: <Id.Lit_ArithVarLike include_system>
                    )
                )
                (BraceGroup
                  children: [(command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<1>})]
                )
              ]
            )
            (command.Simple
              words: [{<declare>} {<-F>} {($ Id.VSub_DollarName '$needed_fn')}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {<'/dev/null'>}
                )
                (redir op:<Id.Redir_GreatAnd '2>&'> loc:(redir_loc.Fd fd:2) arg:{<1>})
              ]
              do_fork: T
            )
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {($ Id.VSub_QMark '$?')}
            )
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_is_traced
      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: {($ Id.VSub_Hyphen '$-')}
                                  right: {<Id.Lit_Other '*'> <x> <Id.Lit_Other '*'>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})]
                  spids: [1134 1150]
                )
              ]
              else_action: [(command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<1>})]
            )
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_linespec_setup
      body: 
        (BraceGroup
          children: [
            (C {<typeset>} 
              {<Id.Lit_VarLike 'linespec='> 
                (braced_var_sub
                  token: <Id.VSub_Number 1>
                  suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:{(SQ )})
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_z
                                  child: {($ Id.VSub_DollarName '$linespec')}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<_Dbg_errmsg>} {(DQ <'Invalid line specification, null given'>)})]
                  spids: [1202 1214]
                )
              ]
            )
            (C {<typeset>} {<-a>} {<word>})
            (C {<eval>} 
              {
                (DQ <'word=('> 
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: (C {<_Dbg_parse_linespec>} {($ Id.VSub_DollarName '$linespec')})
                  ) <')'>
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name word>
                                        prefix_op: (Id.VSub_Pound)
                                        bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                      )
                                    }
                                  right: {<0>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<_Dbg_errmsg>} 
                      {(DQ <'Invalid line specification: '> ($ Id.VSub_DollarName '$linespec'))}
                    )
                    (command.ControlFlow token:<Id.ControlFlow_Return return>)
                  ]
                  spids: [1247 1267]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:filename)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (braced_var_sub
                          token: <Id.VSub_Name word>
                          bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 2>})
                        )
                      )
                    }
                  spids: [1285]
                )
              ]
            )
            (C {<typeset>} {<-ri>} 
              {<Id.Lit_VarLike 'is_function='> 
                (braced_var_sub
                  token: <Id.VSub_Name word>
                  bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 1>})
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:line_number)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name word>
                        bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 0>})
                      )
                    }
                  spids: [1309]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:full_filename)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<_Dbg_is_file>} {(DQ ($ Id.VSub_DollarName '$filename'))})
                      )
                    }
                  spids: [1318]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (command.DParen child:<Id.Lit_ArithVarLike is_function>)
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: {($ Id.VSub_DollarName '$full_filename')}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<_Dbg_readin>} {(DQ ($ Id.VSub_DollarName '$filename'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:full_filename)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<_Dbg_is_file>} {(DQ ($ Id.VSub_DollarName '$filename'))})
                                      )
                                    }
                                  spids: [1365]
                                )
                              ]
                            )
                          ]
                          spids: [1343 1355]
                        )
                      ]
                    )
                  ]
                  spids: [1329 1340]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_parse_linespec
      body: 
        (BraceGroup
          children: [
            (C {<typeset>} {<Id.Lit_VarLike 'linespec='> ($ Id.VSub_Number '$1')})
            (C {<eval>} {(DQ ($ Id.VSub_DollarName '$_seteglob'))})
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$linespec'))}
              arms: [
                (case_arm
                  pat_list: [{($ Id.VSub_DollarName '$int_pat')}]
                  action: [
                    (C {<echo>} 
                      {
                        (DQ ($ Id.VSub_DollarName '$linespec') <' 0 '> 
                          (word_part.EscapedLiteral
                            token: <Id.Lit_EscapedChar '\\"'>
                          ) ($ Id.VSub_DollarName '$_Dbg_frame_last_filename') 
                          (word_part.EscapedLiteral
                            token: <Id.Lit_EscapedChar '\\"'>
                          )
                        )
                      }
                    )
                  ]
                  spids: [1435 1437 1451 -1]
                )
                (case_arm
                  pat_list: [
                    {<Id.Lit_LBracket '['> <Id.Lit_Other '^'> <Id.Lit_Colon ':'> <Id.Lit_RBracket ']'> 
                      <Id.Lit_LBracket '['> <Id.Lit_Other '^'> <Id.Lit_Colon ':'> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'> <Id.Lit_LBracket '['> 
                      <Id.Lit_Colon ':'> <Id.Lit_RBracket ']'> ($ Id.VSub_DollarName '$int_pat')
                    }
                  ]
                  action: [
                    (C {<typeset>} 
                      {<Id.Lit_VarLike 'line_word='> 
                        (braced_var_sub
                          token: <Id.VSub_Name linespec>
                          suffix_op: 
                            (suffix_op.Unary
                              tok: <Id.VOp1_DPound '##'>
                              arg_word: {<Id.Lit_Other '*'> <':'>}
                            )
                        )
                      }
                    )
                    (C {<typeset>} 
                      {<Id.Lit_VarLike 'file_word='> 
                        (braced_var_sub
                          token: <Id.VSub_Name linespec>
                          suffix_op: 
                            (suffix_op.Unary
                              tok: <Id.VOp1_Percent '%'>
                              arg_word: {(${ Id.VSub_Name line_word)}
                            )
                        )
                      }
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:file_word)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <Id.VSub_Name file_word>
                                suffix_op: 
                                  (suffix_op.Unary
                                    tok: <Id.VOp1_Percent '%'>
                                    arg_word: {<Id.Lit_Other '?'>}
                                  )
                              )
                            }
                          spids: [1503]
                        )
                      ]
                    )
                    (C {<echo>} 
                      {
                        (DQ ($ Id.VSub_DollarName '$line_word') <' 0 '> 
                          (word_part.EscapedLiteral
                            token: <Id.Lit_EscapedChar '\\"'>
                          ) ($ Id.VSub_DollarName '$file_word') (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>)
                        )
                      }
                    )
                  ]
                  spids: [1459 1473 1522 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<_Dbg_is_function>} {($ Id.VSub_DollarName '$linespec')} 
                                      {($ Id.VSub_DollarName '$_Dbg_set_debug')}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<local>} {<-a>} 
                              {<Id.Lit_VarLike 'word='> 
                                (sh_array_literal
                                  left: <Id.Op_LParen _>
                                  words: [
                                    {
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<declare>} {<-F>} {($ Id.VSub_DollarName '$linespec')})
                                      )
                                    }
                                  ]
                                )
                              }
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.LogicalAnd
                                                  left: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_GlobDEqual
                                                      left: {<0>}
                                                      right: {($ Id.VSub_QMark '$?')}
                                                    )
                                                  right: 
                                                    (bool_expr.Binary
                                                      op_id: Id.Op_Great
                                                      left: 
                                                        {
                                                          (braced_var_sub
                                                            token: <Id.VSub_Name word>
                                                            prefix_op: (Id.VSub_Pound)
                                                            bracket_op: 
                                                              (bracket_op.WholeArray
                                                                op_id: Id.Lit_At
                                                              )
                                                          )
                                                        }
                                                      right: {<2>}
                                                    )
                                                )
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (C {<builtin>} {<echo>} 
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            token: <Id.VSub_Name word>
                                            bracket_op: 
                                              (bracket_op.ArrayIndex
                                                expr: {<Id.Lit_Digits 1>}
                                              )
                                          ) <' 1 '> 
                                          (braced_var_sub
                                            token: <Id.VSub_Name word>
                                            bracket_op: 
                                              (bracket_op.ArrayIndex
                                                expr: {<Id.Lit_Digits 2>}
                                              )
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  spids: [1566 1593]
                                )
                              ]
                              else_action: [(C {<builtin>} {<echo>} {(SQ )})]
                            )
                          ]
                          spids: [1535 1545]
                        )
                      ]
                      else_action: [(C {<builtin>} {<echo>} {(SQ )})]
                    )
                  ]
                  spids: [1530 1532 1645 -1]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_set_ftrace
      body: 
        (BraceGroup
          children: [
            (C {<typeset>} {<Id.Lit_VarLike 'opt='> <-t>} {<Id.Lit_VarLike 'tmsg='> (DQ <enabled>)} 
              {<Id.KW_Func func>}
            )
            (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_Number '$1')}
                                  right: {<Id.BoolUnary_u -u>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:opt)
                          op: assign_op.Equal
                          rhs: {<Id.Lit_Other '+'> <t>}
                          spids: [1701]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:tmsg)
                          op: assign_op.Equal
                          rhs: {(DQ <disabled>)}
                          spids: [1706]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [1685 1698]
                )
              ]
            )
            (command.ForEach
              iter_name: func
              do_arg_iter: T
              body: 
                (command.DoGroup
                  children: [
                    (C {<declare>} {<-f>} {($ Id.VSub_DollarName '$opt')} 
                      {($ Id.VSub_DollarName '$func')}
                    )
                  ]
                )
            )
          ]
        )
    )
  ]
)