(command.CommandList
  children: [
    (command.CommandList
      children: [
        (command.Sentence child:(C {(typeset)} {(-a)} {(_Dbg_yn)}) terminator:<Op_Semi ';'>)
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:_Dbg_yn)
              op: Equal
              rhs: {(sh_array_literal left:<Op_LParen '('> words:[{(DQ (n))} {(DQ (y))}])}
            )
          ]
        )
      ]
    )
    (command.ShFunction
      name: _Dbg_copies
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:result) op:Equal rhs:{(SQ )})]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.DParen
                  child: 
                    (arith_expr.Binary
                      op_id: Arith_Less
                      left: (arith_expr.ArithWord w:{($ VSub_Pound '$#')})
                      right: (arith_expr.ArithWord w:{(Lit_Digits 2)})
                    )
                )
                (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
            )
            (C {(typeset)} {(-r)} {(Lit_VarLike 'string=') (DQ ($ VSub_Number '$1'))})
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(typeset)} {(-i)} {(Lit_VarLike 'count=') ($ VSub_Number '$2')})
                (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(2)})
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.DParen
                  child: 
                    (arith_expr.Binary
                      op_id: Arith_Great
                      left: (arith_expr.VarRef token:<Lit_ArithVarLike count>)
                      right: (arith_expr.ArithWord w:{(Lit_Digits 0)})
                    )
                )
                (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(3)})
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(builtin)} {(printf)} {(-v)} {(result)} {(DQ ('%') (${ VSub_Name count) (s))} 
                  {(SQ <' '>)}
                )
                (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(3)})
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:result)
                  op: Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <VSub_Name result>
                        suffix_op: 
                          (suffix_op.PatSub
                            pat: {(' ')}
                            replace: {($ VSub_DollarName '$string')}
                            replace_mode: Lit_Slash
                          )
                      )
                    }
                )
              ]
            )
            (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_defined
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.DParen
                  child: 
                    (arith_expr.Binary
                      op_id: Arith_DEqual
                      left: (arith_expr.ArithWord w:{(Lit_Digits 0)})
                      right: (arith_expr.ArithWord w:{($ VSub_Pound '$#')})
                    )
                )
                (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
            )
            (command.Simple
              words: [{(typeset)} {(-p)} {(DQ ($ VSub_Number '$1'))}]
              redirects: [(redir.Redir op:<Redir_AndGreat '&>'> fd:16777215 arg_word:{(/dev/null)})]
            )
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_esc_dq
      body: 
        (command.BraceGroup
          children: [
            (C {(builtin)} {(printf)} {(DQ ('%q') (Lit_Other '\\') (n))} {(DQ ($ VSub_Number '$1'))})
          ]
        )
    )
    (command.Sentence child:(C {(typeset)} {(-a)} {(_Dbg_eval_re)}) terminator:<Op_Semi ';'>)
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:_Dbg_eval_re)
          op: Equal
          rhs: 
            {
              (sh_array_literal
                left: <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 ('^[ ') (Lit_Other '\\') ('t]*[A-Za-z_][A-Za-z_0-9_]*') (Lit_Other '\\') 
                      ('[[0-9]+') (Lit_Other '\\') ('][+-]?=(.*') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (')')
                    )
                  }
                ]
              )
            }
        )
      ]
    )
    (command.ShFunction
      name: _Dbg_eval_extract_condition
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:orig)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$1'))}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: BoolBinary_EqualTilde
                              left: {($ VSub_DollarName '$orig')}
                              right: 
                                {
                                  (braced_var_sub
                                    token: <VSub_Name _Dbg_eval_re>
                                    bracket_op: 
                                      (bracket_op.ArrayIndex
                                        expr: (arith_expr.ArithWord w:{(Lit_Digits 0)})
                                      )
                                  )
                                }
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:extracted)
                          op: Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <VSub_Name BASH_REMATCH>
                                bracket_op: 
                                  (bracket_op.ArrayIndex
                                    expr: (arith_expr.ArithWord w:{(Lit_Digits 2)})
                                  )
                              )
                            }
                        )
                      ]
                    )
                  ]
                )
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: BoolBinary_EqualTilde
                              left: {($ VSub_DollarName '$orig')}
                              right: 
                                {
                                  (braced_var_sub
                                    token: <VSub_Name _Dbg_eval_re>
                                    bracket_op: 
                                      (bracket_op.ArrayIndex
                                        expr: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                      )
                                  )
                                }
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:extracted)
                          op: Equal
                          rhs: 
                            {
                              (DQ ('echo ') 
                                (braced_var_sub
                                  token: <VSub_Name BASH_REMATCH>
                                  bracket_op: 
                                    (bracket_op.ArrayIndex
                                      expr: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                    )
                                )
                              )
                            }
                        )
                      ]
                    )
                  ]
                )
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: BoolBinary_EqualTilde
                              left: {($ VSub_DollarName '$orig')}
                              right: 
                                {
                                  (braced_var_sub
                                    token: <VSub_Name _Dbg_eval_re>
                                    bracket_op: 
                                      (bracket_op.ArrayIndex
                                        expr: (arith_expr.ArithWord w:{(Lit_Digits 2)})
                                      )
                                  )
                                }
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:extracted)
                          op: Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <VSub_Name BASH_REMATCH>
                                bracket_op: 
                                  (bracket_op.ArrayIndex
                                    expr: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                  )
                              )
                            }
                        )
                      ]
                    )
                  ]
                )
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: BoolBinary_EqualTilde
                              left: {($ VSub_DollarName '$orig')}
                              right: 
                                {
                                  (braced_var_sub
                                    token: <VSub_Name _Dbg_eval_re>
                                    bracket_op: 
                                      (bracket_op.ArrayIndex
                                        expr: (arith_expr.ArithWord w:{(Lit_Digits 3)})
                                      )
                                  )
                                }
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:extracted)
                          op: Equal
                          rhs: 
                            {
                              (DQ ('echo ') 
                                (braced_var_sub
                                  token: <VSub_Name BASH_REMATCH>
                                  bracket_op: 
                                    (bracket_op.ArrayIndex
                                      expr: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                    )
                                )
                              )
                            }
                        )
                      ]
                    )
                  ]
                )
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: BoolBinary_EqualTilde
                              left: {($ VSub_DollarName '$orig')}
                              right: 
                                {
                                  (braced_var_sub
                                    token: <VSub_Name _Dbg_eval_re>
                                    bracket_op: 
                                      (bracket_op.ArrayIndex
                                        expr: (arith_expr.ArithWord w:{(Lit_Digits 4)})
                                      )
                                  )
                                }
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:extracted)
                          op: Equal
                          rhs: 
                            {
                              (DQ ('echo ') 
                                (braced_var_sub
                                  token: <VSub_Name BASH_REMATCH>
                                  bracket_op: 
                                    (bracket_op.ArrayIndex
                                      expr: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                    )
                                )
                              )
                            }
                        )
                      ]
                    )
                  ]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:extracted)
                      op: Equal
                      rhs: {($ VSub_DollarName '$orig')}
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_onoff
      body: 
        (command.BraceGroup
          children: [
            (C {(typeset)} {(Lit_VarLike 'onoff=') (SQ <off.>)})
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.DParen
                  child: 
                    (arith_expr.Binary
                      op_id: Arith_NEqual
                      left: (arith_expr.ArithWord w:{($ VSub_Number '$1')})
                      right: (arith_expr.ArithWord w:{(Lit_Digits 0)})
                    )
                )
                (command.ShAssignment
                  pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:onoff) op:Equal rhs:{(SQ <on.>)})]
                )
              ]
            )
            (C {(builtin)} {(echo)} {($ VSub_DollarName '$onoff')})
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_set_dol_q
      body: 
        (command.BraceGroup
          children: [
            (command.ControlFlow
              token: <ControlFlow_Return return>
              arg_word: 
                {
                  (braced_var_sub
                    token: <VSub_Number 1>
                    suffix_op: 
                      (suffix_op.Unary
                        op_id: VTest_ColonHyphen
                        arg_word: {($ VSub_DollarName '$_Dbg_debugged_exit_code')}
                      )
                  )
                }
            )
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_split
      body: 
        (command.BraceGroup
          children: [
            (C {(typeset)} {(Lit_VarLike 'old_IFS=') ($ VSub_DollarName '$IFS')})
            (C {(typeset)} 
              {(Lit_VarLike 'new_ifs=') 
                (braced_var_sub
                  token: <VSub_Number 1>
                  suffix_op: (suffix_op.Unary op_id:VTest_ColonHyphen arg_word:{(SQ <' '>)})
                )
              }
            )
            (C {(shift)})
            (C {(typeset)} {(-r)} {(Lit_VarLike 'text=') (DQ ($ VSub_Star '$*'))})
            (C {(typeset)} {(-a)} {(array)})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:IFS)
                  op: Equal
                  rhs: {(DQ ($ VSub_DollarName '$new_ifs'))}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:array)
                  op: Equal
                  rhs: {(sh_array_literal left:<Op_LParen '('> words:[{($ VSub_DollarName '$text')}])}
                )
              ]
            )
            (C {(echo)} 
              {
                (braced_var_sub
                  token: <VSub_Name array>
                  bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:IFS)
                  op: Equal
                  rhs: {($ VSub_DollarName '$old_IFS')}
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_get_functions
      body: 
        (command.BraceGroup
          children: [
            (C {(typeset)} {(-i)} 
              {(Lit_VarLike 'include_system=') 
                (braced_var_sub
                  token: <VSub_Number 1>
                  suffix_op: (suffix_op.Unary op_id:VTest_ColonHyphen arg_word:{(0)})
                )
              }
            )
            (C {(typeset)} 
              {(Lit_VarLike 'pat=') 
                (braced_var_sub
                  token: <VSub_Number 2>
                  suffix_op: (suffix_op.Unary op_id:VTest_ColonHyphen arg_word:{('.*')})
                )
              }
            )
            (C {(typeset)} {(-a)} {(fns_a)})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:fns_a)
                  op: Equal
                  rhs: 
                    {
                      (sh_array_literal
                        left: <Op_LParen '('>
                        words: [
                          {
                            (command_sub
                              left_token: <Left_DollarParen '$('>
                              command_list: (command.CommandList children:[(C {(declare)} {(-F)})])
                            )
                          }
                        ]
                      )
                    }
                )
              ]
            )
            (C {(typeset)} {(-a)} {(Lit_VarLike 'ret_fns=') (sh_array_literal left:<Op_LParen '('>)})
            (C {(typeset)} {(-i)} {(i)})
            (command.Sentence
              child: (C {(typeset)} {(-i)} {(Lit_VarLike 'invert=') (0)})
              terminator: <Op_Semi ';'>
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: BoolBinary_GlobDEqual
                              left: {($ VSub_DollarName '$pat')}
                              right: {(KW_Bang '!') (Lit_Other '*')}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:pat)
                          op: Equal
                          rhs: 
                            {(Lit_Pound '#') (Lit_LBrace '{') ($ VSub_DollarName '$pat') 
                              (Lit_Pound '#') (KW_Bang '!') (Lit_RBrace '}')
                            }
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:invert) op:Equal rhs:{(1)})]
                    )
                  ]
                )
              ]
            )
            (command.ForExpr
              init: 
                (arith_expr.BinaryAssign
                  op_id: Arith_Equal
                  left: (sh_lhs_expr.Name name:i)
                  right: (arith_expr.ArithWord w:{(Lit_Digits 2)})
                )
              cond: 
                (arith_expr.Binary
                  op_id: Arith_Less
                  left: (arith_expr.VarRef token:<Lit_ArithVarLike i>)
                  right: 
                    (arith_expr.ArithWord
                      w: 
                        {
                          (braced_var_sub
                            token: <VSub_Name fns_a>
                            prefix_op: VSub_Pound
                            bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                          )
                        }
                    )
                )
              update: 
                (arith_expr.BinaryAssign
                  op_id: Arith_PlusEqual
                  left: (sh_lhs_expr.Name name:i)
                  right: (arith_expr.ArithWord w:{(Lit_Digits 3)})
                )
              body: 
                (command.DoGroup
                  children: [
                    (C {(typeset)} 
                      {(Lit_VarLike 'fn=') 
                        (DQ 
                          (braced_var_sub
                            token: <VSub_Name fns_a>
                            bracket_op: 
                              (bracket_op.ArrayIndex
                                expr: (arith_expr.ArithWord w:{($ VSub_DollarName '$i')})
                              )
                          )
                        )
                      }
                    )
                    (command.AndOr
                      ops: [Op_DAmp Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: BoolBinary_GlobDEqual
                              left: {($ VSub_DollarName '$fn')}
                              right: {(_) (Lit_Other '*')}
                            )
                        )
                        (command.DParen
                          child: 
                            (arith_expr.Unary
                              op_id: Arith_Bang
                              child: (arith_expr.VarRef token:<Lit_ArithVarLike include_system>)
                            )
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Continue continue>
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: BoolBinary_EqualTilde
                                      left: {($ VSub_DollarName '$fn')}
                                      right: {($ VSub_DollarName '$pat')}
                                    )
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: BoolBinary_GlobDEqual
                                      left: {($ VSub_DollarName '$invert')}
                                      right: {(0)}
                                    )
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: 
                                        (sh_lhs_expr.IndexedName
                                          name: ret_fns
                                          index: 
                                            (arith_expr.ArithWord
                                              w: 
                                                {
                                                  (braced_var_sub
                                                    token: <VSub_Name ret_fns>
                                                    prefix_op: VSub_Pound
                                                    bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                                  )
                                                }
                                            )
                                        )
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$fn')}
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      else_action: [
                        (command.AndOr
                          ops: [Op_DAmp]
                          children: [
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: BoolBinary_GlobNEqual
                                  left: {($ VSub_DollarName '$invert')}
                                  right: {(0)}
                                )
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.IndexedName
                                      name: ret_fns
                                      index: 
                                        (arith_expr.ArithWord
                                          w: 
                                            {
                                              (braced_var_sub
                                                token: <VSub_Name ret_fns>
                                                prefix_op: VSub_Pound
                                                bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                              )
                                            }
                                        )
                                    )
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$fn')}
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
            )
            (C {(echo)} 
              {
                (braced_var_sub
                  token: <VSub_Name ret_fns>
                  bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                )
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_is_function
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.DParen
                  child: 
                    (arith_expr.Binary
                      op_id: Arith_DEqual
                      left: (arith_expr.ArithWord w:{(Lit_Digits 0)})
                      right: (arith_expr.ArithWord w:{($ VSub_Pound '$#')})
                    )
                )
                (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
            )
            (C {(typeset)} {(Lit_VarLike 'needed_fn=') ($ VSub_Number '$1')})
            (C {(typeset)} {(-i)} 
              {(Lit_VarLike 'include_system=') 
                (braced_var_sub
                  token: <VSub_Number 2>
                  suffix_op: (suffix_op.Unary op_id:VTest_ColonHyphen arg_word:{(0)})
                )
              }
            )
            (command.AndOr
              ops: [Op_DAmp Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Binary
                      op_id: BoolBinary_GlobDEqual
                      left: 
                        {
                          (braced_var_sub
                            token: <VSub_Name needed_fn>
                            suffix_op: 
                              (suffix_op.Slice
                                begin: (arith_expr.ArithWord w:{(Lit_Digits 0)})
                                length: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                              )
                          )
                        }
                      right: {(SQ <_>)}
                    )
                )
                (command.DParen
                  child: 
                    (arith_expr.Unary
                      op_id: Arith_Bang
                      child: (arith_expr.VarRef token:<Lit_ArithVarLike include_system>)
                    )
                )
                (command.BraceGroup
                  children: [(command.ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})]
                )
              ]
            )
            (command.Simple
              words: [{(declare)} {(-F)} {($ VSub_DollarName '$needed_fn')}]
              redirects: [
                (redir.Redir op:<Redir_Great '>'> fd:16777215 arg_word:{(/dev/null)})
                (redir.Redir op:<Redir_GreatAnd '2>&'> fd:2 arg_word:{(1)})
              ]
            )
            (command.ControlFlow
              token: <ControlFlow_Return return>
              arg_word: {($ VSub_QMark '$?')}
            )
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_is_traced
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: BoolBinary_GlobDEqual
                              left: {($ VSub_Hyphen '$-')}
                              right: {(Lit_Other '*') (x) (Lit_Other '*')}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [(command.ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                )
              ]
              else_action: [(command.ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})]
            )
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_linespec_setup
      body: 
        (command.BraceGroup
          children: [
            (C {(typeset)} 
              {(Lit_VarLike 'linespec=') 
                (braced_var_sub
                  token: <VSub_Number 1>
                  suffix_op: (suffix_op.Unary op_id:VTest_ColonHyphen arg_word:{(SQ )})
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: BoolUnary_z
                              child: {($ VSub_DollarName '$linespec')}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [(C {(_Dbg_errmsg)} {(DQ ('Invalid line specification, null given'))})]
                )
              ]
            )
            (C {(typeset)} {(-a)} {(word)})
            (C {(eval)} 
              {
                (DQ ('word=(') 
                  (command_sub
                    left_token: <Left_DollarParen '$('>
                    command_list: 
                      (command.CommandList
                        children: [(C {(_Dbg_parse_linespec)} {($ VSub_DollarName '$linespec')})]
                      )
                  ) (')')
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: BoolBinary_GlobDEqual
                              left: 
                                {
                                  (braced_var_sub
                                    token: <VSub_Name word>
                                    prefix_op: VSub_Pound
                                    bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                  )
                                }
                              right: {(0)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(_Dbg_errmsg)} 
                      {(DQ ('Invalid line specification: ') ($ VSub_DollarName '$linespec'))}
                    )
                    (command.ControlFlow token:<ControlFlow_Return return>)
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:filename)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (braced_var_sub
                          token: <VSub_Name word>
                          bracket_op: 
                            (bracket_op.ArrayIndex
                              expr: (arith_expr.ArithWord w:{(Lit_Digits 2)})
                            )
                        )
                      )
                    }
                )
              ]
            )
            (C {(typeset)} {(-ri)} 
              {(Lit_VarLike 'is_function=') 
                (braced_var_sub
                  token: <VSub_Name word>
                  bracket_op: (bracket_op.ArrayIndex expr:(arith_expr.ArithWord w:{(Lit_Digits 1)}))
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:line_number)
                  op: Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <VSub_Name word>
                        bracket_op: 
                          (bracket_op.ArrayIndex
                            expr: (arith_expr.ArithWord w:{(Lit_Digits 0)})
                          )
                      )
                    }
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:full_filename)
                  op: Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Left_DollarParen '$('>
                        command_list: 
                          (command.CommandList
                            children: [(C {(_Dbg_is_file)} {(DQ ($ VSub_DollarName '$filename'))})]
                          )
                      )
                    }
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DParen
                          child: (arith_expr.VarRef token:<Lit_ArithVarLike is_function>)
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Unary
                                      op_id: BoolUnary_z
                                      child: {($ VSub_DollarName '$full_filename')}
                                    )
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(_Dbg_readin)} {(DQ ($ VSub_DollarName '$filename'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:full_filename)
                                  op: Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Left_DollarParen '$('>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(_Dbg_is_file)} {(DQ ($ VSub_DollarName '$filename'))})
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_parse_linespec
      body: 
        (command.BraceGroup
          children: [
            (C {(typeset)} {(Lit_VarLike 'linespec=') ($ VSub_Number '$1')})
            (C {(eval)} {(DQ ($ VSub_DollarName '$_seteglob'))})
            (command.Case
              to_match: {(DQ ($ VSub_DollarName '$linespec'))}
              arms: [
                (case_arm
                  pat_list: [{($ VSub_DollarName '$int_pat')}]
                  action: [
                    (C {(echo)} 
                      {
                        (DQ ($ VSub_DollarName '$linespec') (' 0 ') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) ($ VSub_DollarName '$_Dbg_frame_last_filename') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          )
                        )
                      }
                    )
                  ]
                )
                (case_arm
                  pat_list: [
                    {(Lit_LBracket '[') (Lit_Other '^') (Lit_Other ':') (Lit_RBracket ']') 
                      (Lit_LBracket '[') (Lit_Other '^') (Lit_Other ':') (Lit_RBracket ']') (Lit_Star '*') (Lit_LBracket '[') (Lit_Other ':') 
                      (Lit_RBracket ']') ($ VSub_DollarName '$int_pat')
                    }
                  ]
                  action: [
                    (C {(typeset)} 
                      {(Lit_VarLike 'line_word=') 
                        (braced_var_sub
                          token: <VSub_Name linespec>
                          suffix_op: (suffix_op.Unary op_id:VOp1_DPound arg_word:{('*:')})
                        )
                      }
                    )
                    (C {(typeset)} 
                      {(Lit_VarLike 'file_word=') 
                        (braced_var_sub
                          token: <VSub_Name linespec>
                          suffix_op: 
                            (suffix_op.Unary
                              op_id: VOp1_Percent
                              arg_word: {(${ VSub_Name line_word)}
                            )
                        )
                      }
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:file_word)
                          op: Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <VSub_Name file_word>
                                suffix_op: (suffix_op.Unary op_id:VOp1_Percent arg_word:{('?')})
                              )
                            }
                        )
                      ]
                    )
                    (C {(echo)} 
                      {
                        (DQ ($ VSub_DollarName '$line_word') (' 0 ') 
                          (word_part.EscapedLiteral
                            token: <Lit_EscapedChar '\\"'>
                          ) ($ VSub_DollarName '$file_word') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                        )
                      }
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(_Dbg_is_function)} {($ VSub_DollarName '$linespec')} 
                                  {($ VSub_DollarName '$_Dbg_set_debug')}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(local)} {(-a)} 
                              {(Lit_VarLike 'word=') 
                                (sh_array_literal
                                  left: <Op_LParen '('>
                                  words: [
                                    {
                                      (command_sub
                                        left_token: <Left_DollarParen '$('>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(declare)} {(-F)} {($ VSub_DollarName '$linespec')})
                                            ]
                                          )
                                      )
                                    }
                                  ]
                                )
                              }
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.LogicalAnd
                                              left: 
                                                (bool_expr.Binary
                                                  op_id: BoolBinary_GlobDEqual
                                                  left: {(0)}
                                                  right: {($ VSub_QMark '$?')}
                                                )
                                              right: 
                                                (bool_expr.Binary
                                                  op_id: Op_Great
                                                  left: 
                                                    {
                                                      (braced_var_sub
                                                        token: <VSub_Name word>
                                                        prefix_op: VSub_Pound
                                                        bracket_op: 
                                                          (bracket_op.WholeArray
                                                            op_id: Lit_At
                                                          )
                                                      )
                                                    }
                                                  right: {(2)}
                                                )
                                            )
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(builtin)} {(echo)} 
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            token: <VSub_Name word>
                                            bracket_op: 
                                              (bracket_op.ArrayIndex
                                                expr: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                              )
                                          ) (' 1 ') 
                                          (braced_var_sub
                                            token: <VSub_Name word>
                                            bracket_op: 
                                              (bracket_op.ArrayIndex
                                                expr: (arith_expr.ArithWord w:{(Lit_Digits 2)})
                                              )
                                          )
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                              else_action: [(C {(builtin)} {(echo)} {(SQ )})]
                            )
                          ]
                        )
                      ]
                      else_action: [(C {(builtin)} {(echo)} {(SQ )})]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_set_ftrace
      body: 
        (command.BraceGroup
          children: [
            (C {(typeset)} {(Lit_VarLike 'opt=') (-t)} {(Lit_VarLike 'tmsg=') (DQ (enabled))} 
              {(KW_Func func)}
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: BoolBinary_GlobDEqual
                              left: {($ VSub_Number '$1')}
                              right: {(BoolUnary_u -u)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:opt)
                          op: Equal
                          rhs: {(Lit_Other '+') (t)}
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:tmsg)
                          op: Equal
                          rhs: {(DQ (disabled))}
                        )
                      ]
                    )
                    (C {(shift)})
                  ]
                )
              ]
            )
            (command.ForEach
              iter_name: func
              do_arg_iter: T
              body: 
                (command.DoGroup
                  children: [
                    (C {(declare)} {(-f)} {($ VSub_DollarName '$opt')} {($ VSub_DollarName '$func')})
                  ]
                )
            )
          ]
        )
    )
  ]
)