(CommandList
  children: [
    (C {(typeset)} {(-i)} {(Lit_VarLike "_Dbg_inside_skip=") (0)})
    (C {(typeset)} {(-A)} {(_Dbg_cmdloop_hooks)})
    (C 
      {(_Dbg_cmdloop_hooks) (Lit_Other "[") (SQ <display>) (Lit_Other "]") (Lit_Other "=") 
        (SQ <_Dbg_eval_all_display>)
      }
    )
    (Sentence child:(C {(typeset)} {(_Dbg_read_fn)}) terminator:<Op_Semi ";">)
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:_Dbg_read_fn) op:Equal rhs:{(SQ <read>)} spids:[104])]
      spids: [104]
    )
    (C {(typeset)} {(Lit_VarLike "_Dbg_space=") (SQ <" ">)})
    (C {(typeset)} {(Lit_VarLike "_Dbg_edit=") (SQ <-e>)})
    (C {(typeset)} {(Lit_VarLike "_Dbg_edit_style=") (SQ <emacs>)})
    (C {(set)} {(-o)} {($ VSub_Name "$_Dbg_edit_style")})
    (C {(typeset)} 
      {(Lit_VarLike "_Dbg_prompt_str=") 
        (SQ <"$_Dbg_debugger_name${_Dbg_less}${#_Dbg_history[@]}${_Dbg_greater}$_Dbg_space">)
      }
    )
    (C {(typeset)} {(Lit_VarLike "_Dbg_last_x_args=") (SQ )})
    (C {(typeset)} {(Lit_VarLike "_Dbg_last_cmd=") (SQ )})
    (Sentence child:(C {(typeset)} {(-i)} {(_Dbg_fdi)}) terminator:<Op_Semi ";">)
    (SimpleCommand
      words: [{(exec)} {(Lit_LBrace "{") (_Dbg_fdi) (Lit_RBrace "}")}]
      redirects: [(Redir op_id:Redir_LessAnd fd:-1 arg_word:{(0)} spids:[222])]
    )
    (C {(typeset)} {(-i)} {(Lit_VarLike "_Dbg_fd_last=") (0)})
    (Sentence child:(C {(typeset)} {(-a)} {(_Dbg_cmdfile)}) terminator:<Op_Semi ";">)
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_Dbg_cmdfile)
          op: Equal
          rhs: {(ArrayLiteralPart words:[{(SQ )}])}
          spids: [247]
        )
      ]
      spids: [247]
    )
    (Sentence child:(C {(typeset)} {(-a)} {(_Dbg_fd)}) terminator:<Op_Semi ";">)
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_Dbg_fd)
          op: Equal
          rhs: {(ArrayLiteralPart words:[{($ VSub_Name "$_Dbg_fdi")}])}
          spids: [264]
        )
      ]
      spids: [264]
    )
    (C {(typeset)} {(_Dbg_prompt_output)})
    (FuncDef
      name: _Dbg_process_commands
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:_Dbg_inside_skip)
                  op: Equal
                  rhs: {(0)}
                  spids: [330]
                )
              ]
              spids: [330]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:_Dbg_step_ignore)
                  op: Equal
                  rhs: {(-1)}
                  spids: [334]
                )
              ]
              spids: [334]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:_Dbg_continue_rc)
                  op: Equal
                  rhs: {(-1)}
                  spids: [341]
                )
              ]
              spids: [341]
            )
            (C {(_Dbg_write_journal)} {(DQ ("_Dbg_step_ignore=") ($ VSub_Name "$_Dbg_step_ignore"))})
            (C {(typeset)} {(key)})
            (ForEach
              iter_name: key
              iter_words: [
                {
                  (BracedVarSub
                    token: <VSub_Name _Dbg_cmdloop_hooks>
                    prefix_op: VSub_Bang
                    bracket_op: (WholeArray op_id:Lit_At)
                    spids: [373 379]
                  )
                }
              ]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (C 
                      {
                        (BracedVarSub
                          token: <VSub_Name _Dbg_cmdloop_hooks>
                          bracket_op: (ArrayIndex expr:(ArithWord w:{($ VSub_Name "$key")}))
                          spids: [386 391]
                        )
                      }
                    )
                  ]
                  spids: [383 394]
                )
              spids: [372 381]
            )
            (While
              cond: [
                (Sentence
                  child: 
                    (DParen
                      child: 
                        (ArithBinary
                          op_id: Arith_Great
                          left: (ArithVarRef name:_Dbg_fd_last)
                          right: (ArithWord w:{(Lit_Digits 0)})
                        )
                    )
                  terminator: <Op_Semi ";">
                )
              ]
              body: 
                (DoGroup
                  children: [
                    (C {(typeset)} {(Lit_VarLike "_Dbg_greater=") (SQ )})
                    (C {(typeset)} {(Lit_VarLike "_Dbg_less=") (SQ )})
                    (C {(typeset)} {(result)})
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(_Dbg_copies)} {(SQ <">">)} {($ VSub_Name "$_Dbg_DEBUGGER_LEVEL")})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:_Dbg_greater)
                                  op: Equal
                                  rhs: {($ VSub_Name "$result")}
                                  spids: [462]
                                )
                              ]
                              spids: [462]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:_Dbg_less)
                                  op: Equal
                                  rhs: 
                                    {
                                      (BracedVarSub
                                        token: <VSub_Name result>
                                        suffix_op: 
                                          (PatSub
                                            pat: {(Lit_Other ">")}
                                            replace: {(Lit_Other "<")}
                                            do_all: True
                                            do_prefix: False
                                            do_suffix: False
                                          )
                                        spids: [467 474]
                                      )
                                    }
                                  spids: [466]
                                )
                              ]
                              spids: [466]
                            )
                          ]
                          spids: [-1 459]
                        )
                      ]
                      spids: [-1 477]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(_Dbg_copies)} {(SQ <")">)} {($ VSub_Name "$BASH_SUBSHELL")})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:_Dbg_greater)
                                  op: Equal
                                  rhs: {(DQ (${ VSub_Name result) (${ VSub_Name _Dbg_greater))}
                                  spids: [495]
                                )
                              ]
                              spids: [495]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:_Dbg_less)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ (${ VSub_Name _Dbg_less) 
                                        (BracedVarSub
                                          token: <VSub_Name result>
                                          suffix_op: 
                                            (PatSub
                                              pat: {(")")}
                                              replace: {("(")}
                                              do_all: True
                                              do_prefix: False
                                              do_suffix: False
                                            )
                                          spids: [511 518]
                                        )
                                      )
                                    }
                                  spids: [506]
                                )
                              ]
                              spids: [506]
                            )
                          ]
                          spids: [-1 492]
                        )
                      ]
                      spids: [-1 522]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:_Dbg_prompt_output)
                          op: Equal
                          rhs: 
                            {
                              (BracedVarSub
                                token: <VSub_Name _Dbg_tty>
                                suffix_op: 
                                  (StringUnary
                                    op_id: VTest_ColonHyphen
                                    arg_word: {(Lit_Slash /) (dev) (Lit_Slash /) (null)}
                                  )
                                spids: [577 584]
                              )
                            }
                          spids: [576]
                        )
                      ]
                      spids: [576]
                    )
                    (C {(eval)} {(DQ ("local _Dbg_prompt=") ($ VSub_Name "$_Dbg_prompt_str"))})
                    (C {(_Dbg_preloop)})
                    (C {(typeset)} {(_Dbg_cmd)})
                    (C {(typeset)} {(args)})
                    (C {(typeset)} {(rc)})
                    (While
                      cond: [(Sentence child:(C {(Lit_Other ":")}) terminator:<Op_Semi ";">)]
                      body: 
                        (DoGroup
                          children: [
                            (C {(set)} {(-o)} {(history)})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:_Dbg_input_desc)
                                  op: Equal
                                  rhs: 
                                    {
                                      (BracedVarSub
                                        token: <VSub_Name _Dbg_fd>
                                        bracket_op: (ArrayIndex expr:(ArithVarRef name:_Dbg_fd_last))
                                        spids: [633 638]
                                      )
                                    }
                                  spids: [632]
                                )
                              ]
                              spids: [632]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DBracket
                                          expr: 
                                            (BoolBinary
                                              op_id: BoolBinary_GlobDEqual
                                              left: {($ VSub_Name "$_Dbg_tty")}
                                              right: {(SQ <"&1">)}
                                            )
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (C {(echo)} {(-n)} {(DQ ($ VSub_Name "$_Dbg_prompt"))})
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (Pipeline
                                                  children: [
                                                    (SimpleCommand
                                                      words: [{(read)} {(_Dbg_cmd)} {(args)}]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_LessAnd
                                                          fd: -1
                                                          arg_word: {($ VSub_Name "$_Dbg_input_desc")}
                                                          spids: [679]
                                                        )
                                                        (Redir
                                                          op_id: Redir_GreatAnd
                                                          fd: 2
                                                          arg_word: {(1)}
                                                          spids: [682]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                  negated: True
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [(ControlFlow token:<ControlFlow_Break break>)]
                                          spids: [-1 686]
                                        )
                                      ]
                                      spids: [-1 692]
                                    )
                                  ]
                                  spids: [-1 657]
                                )
                              ]
                              else_action: [
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (Sentence
                                          child: 
                                            (DParen
                                              child: (ArithVarRef name:_Dbg_set_read_completion)
                                            )
                                          terminator: <Op_Semi ";">
                                        )
                                      ]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:_Dbg_read_fn)
                                              op: Equal
                                              rhs: {(SQ <readc>)}
                                              spids: [710]
                                            )
                                          ]
                                          spids: [710]
                                        )
                                      ]
                                      spids: [-1 707]
                                    )
                                  ]
                                  else_action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:_Dbg_read_fn)
                                          op: Equal
                                          rhs: {(SQ <read>)}
                                          spids: [719]
                                        )
                                      ]
                                      spids: [719]
                                    )
                                  ]
                                  spids: [716 725]
                                )
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (Sentence
                                          child: 
                                            (Pipeline
                                              children: [
                                                (SimpleCommand
                                                  words: [
                                                    {($ VSub_Name "$_Dbg_read_fn")}
                                                    {($ VSub_Name "$_Dbg_edit")}
                                                    {(-p)}
                                                    {(DQ ($ VSub_Name "$_Dbg_prompt"))}
                                                    {(_Dbg_cmd)}
                                                    {(args)}
                                                  ]
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_LessAnd
                                                      fd: -1
                                                      arg_word: {($ VSub_Name "$_Dbg_input_desc")}
                                                      spids: [748]
                                                    )
                                                    (Redir
                                                      op_id: Redir_DGreat
                                                      fd: 2
                                                      arg_word: {($ VSub_Name "$_Dbg_prompt_output")}
                                                      spids: [751]
                                                    )
                                                  ]
                                                )
                                              ]
                                              negated: True
                                            )
                                          terminator: <Op_Semi ";">
                                        )
                                      ]
                                      action: [
                                        (C {(set)} {(Lit_Other "+") (o)} {(history)})
                                        (ControlFlow
                                          token: <ControlFlow_Break break>
                                        )
                                      ]
                                      spids: [-1 756]
                                    )
                                  ]
                                  spids: [-1 770]
                                )
                              ]
                              spids: [695 773]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DBracket
                                          expr: 
                                            (LogicalAnd
                                              left: 
                                                (BoolBinary
                                                  op_id: BoolBinary_EqualTilde
                                                  left: {($ VSub_Name "$_Dbg_cmd")}
                                                  right: {(SQ <" ">)}
                                                )
                                              right: 
                                                (BoolUnary
                                                  op_id: BoolUnary_z
                                                  child: {($ VSub_Name "$args")}
                                                )
                                            )
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Sentence
                                      child: (C {(typeset)} {(-a)} {(ary)})
                                      terminator: <Op_Semi ";">
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:IFS)
                                          op: Equal
                                          rhs: {(SQ <" ">)}
                                          spids: [817]
                                        )
                                        (assign_pair
                                          lhs: (LhsName name:ary)
                                          op: Equal
                                          rhs: 
                                            {(ArrayLiteralPart words:[{($ VSub_Name "$_Dbg_cmd")}])}
                                          spids: [822]
                                        )
                                      ]
                                      spids: [817]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:_Dbg_cmd)
                                          op: Equal
                                          rhs: 
                                            {
                                              (BracedVarSub
                                                token: <VSub_Name ary>
                                                bracket_op: 
                                                  (ArrayIndex
                                                    expr: (ArithWord w:{(Lit_Digits 0)})
                                                  )
                                                spids: [831 836]
                                              )
                                            }
                                          spids: [830]
                                        )
                                      ]
                                      spids: [830]
                                    )
                                    (C {(unset)} {(ary) (Lit_Other "[") (0) (Lit_Other "]")})
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:args)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (BracedVarSub
                                                  token: <VSub_Name ary>
                                                  bracket_op: (WholeArray op_id:Lit_At)
                                                  spids: [849 854]
                                                )
                                              )
                                            }
                                          spids: [847]
                                        )
                                      ]
                                      spids: [847]
                                    )
                                  ]
                                  spids: [-1 807]
                                )
                              ]
                              spids: [-1 858]
                            )
                            (C {(set)} {(Lit_Other "+") (o)} {(history)})
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DParen
                                          child: (ArithVarRef name:_Dbg_brkpt_commands_defining)
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Case
                                      to_match: {($ VSub_Name "$_Dbg_cmd")}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(silent)}]
                                          action: [
                                            (C 
                                              {(_Dbg_brkpt_commands_silent) (Lit_Other "[") 
                                                ($ VSub_Name "$_Dbg_brkpt_commands_current") (Lit_Other "]") (Lit_Other "=") (1)
                                              }
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [890 892 906 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(end)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:_Dbg_brkpt_commands_defining)
                                                  op: Equal
                                                  rhs: {(0)}
                                                  spids: [914]
                                                )
                                              ]
                                              spids: [914]
                                            )
                                            (C {(eval)} 
                                              {
                                                (DQ ("_Dbg_prompt=") ($ VSub_Name "$_Dbg_prompt_str"))
                                              }
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [909 911 965 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (C 
                                              {(_Dbg_brkpt_commands) (Lit_Other "[") 
                                                (BracedVarSub
                                                  token: <VSub_Name _Dbg_brkpt_commands>
                                                  prefix_op: VSub_Pound
                                                  bracket_op: (WholeArray op_id:Lit_At)
                                                  spids: [974 980]
                                                ) (Lit_Other "]") (Lit_Other "=") (DQ ($ VSub_Name "$_Dbg_cmd") (" ") ($ VSub_Name "$args"))
                                              }
                                            )
                                            (DParen
                                              child: 
                                                (UnaryAssign
                                                  op_id: Node_PostDPlus
                                                  child: 
                                                    (LhsIndexedName
                                                      name: _Dbg_brkpt_commands_end
                                                      index: 
                                                        (ArithWord
                                                          w: 
                                                            {
                                                              ($ VSub_Name 
"$_Dbg_brkpt_commands_current"
                                                              )
                                                            }
                                                        )
                                                    )
                                                )
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [968 969 1005 -1]
                                        )
                                      ]
                                      spids: [883 887 1008]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:rc)
                                          op: Equal
                                          rhs: {($ VSub_QMark "$?")}
                                          spids: [1011]
                                        )
                                      ]
                                      spids: [1011]
                                    )
                                  ]
                                  spids: [-1 880]
                                )
                              ]
                              else_action: [
                                (C {(_Dbg_onecmd)} {(DQ ($ VSub_Name "$_Dbg_cmd"))} 
                                  {(DQ ($ VSub_Name "$args"))}
                                )
                                (C {(_Dbg_postcmd)})
                              ]
                              spids: [1015 1032]
                            )
                            (AndOr
                              children: [
                                (DParen
                                  child: 
                                    (ArithBinary
                                      op_id: Arith_GreatEqual
                                      left: (ArithVarRef name:_Dbg_continue_rc)
                                      right: (ArithWord w:{(Lit_Digits 0)})
                                    )
                                )
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {($ VSub_Name "$_Dbg_continue_rc")}
                                )
                              ]
                              op_id: Op_DAmp
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DParen
                                          child: (ArithVarRef name:_Dbg_brkpt_commands_defining)
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:_Dbg_prompt)
                                          op: Equal
                                          rhs: {(SQ <">">)}
                                          spids: [1066]
                                        )
                                      ]
                                      spids: [1066]
                                    )
                                  ]
                                  spids: [-1 1063]
                                )
                              ]
                              else_action: [
                                (C {(eval)} {(DQ ("_Dbg_prompt=") ($ VSub_Name "$_Dbg_prompt_str"))})
                              ]
                              spids: [1072 1083]
                            )
                          ]
                          spids: [622 1087]
                        )
                    )
                    (C {(unset)} {(_Dbg_fd) (Lit_Other "[") (_Dbg_fd_last--) (Lit_Other "]")})
                  ]
                  spids: [416 1102]
                )
            )
            (C {(_Dbg_msg)} {(SQ )})
            (C {(_Dbg_do_quit)})
          ]
          spids: [301]
        )
      spids: [297 300]
    )
    (FuncDef
      name: _Dbg_annotation
      body: 
        (BraceGroup
          children: [
            (C {(typeset)} {(Lit_VarLike "label=") (DQ ($ VSub_Number "$1"))})
            (C {(shift)})
            (C {(_Dbg_do_print)} {(DQ ("\u001a\u001a") ($ VSub_Name "$label"))})
            (C {($ VSub_Star "$*")})
            (C {(_Dbg_do_print)} {(SQ <"\u001a\u001a">)})
          ]
          spids: [1134]
        )
      spids: [1130 1133]
    )
    (FuncDef
      name: _Dbg_onecmd
      body: 
        (BraceGroup
          children: [
            (C {(typeset)} {(Lit_VarLike "full_cmd=") ($ VSub_At "$@")})
            (C {(typeset)} {(Lit_VarLike "_Dbg_orig_cmd=") (DQ ($ VSub_Number "$1"))})
            (Sentence child:(C {(typeset)} {(expanded_alias)}) terminator:<Op_Semi ";">)
            (C {(_Dbg_alias_expand)} {(DQ ($ VSub_Name "$_Dbg_orig_cmd"))})
            (C {(typeset)} {(Lit_VarLike "_Dbg_cmd=") (DQ ($ VSub_Name "$expanded_alias"))})
            (C {(shift)})
            (C {(typeset)} {(Lit_VarLike "_Dbg_args=") (DQ ($ VSub_At "$@"))})
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: (BoolUnary op_id:BoolUnary_z child:{($ VSub_Name "$_Dbg_cmd")})
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:_Dbg_cmd)
                          op: Equal
                          rhs: {($ VSub_Name "$_Dbg_last_next_step_cmd")}
                          spids: [1248]
                        )
                      ]
                      spids: [1248]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:_Dbg_args)
                          op: Equal
                          rhs: {($ VSub_Name "$_Dbg_last_next_step_args")}
                          spids: [1252]
                        )
                      ]
                      spids: [1252]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:full_cmd)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$_Dbg_cmd") (" ") ($ VSub_Name "$_Dbg_args"))}
                          spids: [1256]
                        )
                      ]
                      spids: [1256]
                    )
                  ]
                  spids: [-1 1245]
                )
              ]
              spids: [-1 1264]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobDEqual
                              left: {($ VSub_Name "$_Dbg_set_trace_commands")}
                              right: {(SQ <on>)}
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [(C {(_Dbg_msg)} {(DQ ("+") ($ VSub_Name "$full_cmd"))})]
                  spids: [-1 1288]
                )
              ]
              spids: [-1 1299]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:dq_cmd)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(_Dbg_esc_dq)} {(DQ ($ VSub_Name "$_Dbg_cmd"))})]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [1306 1312]
                      )
                    }
                  spids: [1305]
                )
              ]
              spids: [1303]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:dq_args)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(_Dbg_esc_dq)} {(DQ ($ VSub_Name "$_Dbg_args"))})]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [1318 1324]
                      )
                    }
                  spids: [1317]
                )
              ]
              spids: [1315]
            )
            (C {(_Dbg_write_journal)} 
              {
                (DQ ("_Dbg_history[") 
                  (BracedVarSub
                    token: <VSub_Name _Dbg_history>
                    prefix_op: VSub_Pound
                    bracket_op: (WholeArray op_id:Lit_At)
                    spids: [1342 1348]
                  ) ("]=") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ($ VSub_Name "$dq_cmd") (" ") 
                  ($ VSub_Name "$dq_args") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                )
              }
            )
            (C 
              {(_Dbg_history) (Lit_Other "[") 
                (BracedVarSub
                  token: <VSub_Name _Dbg_history>
                  prefix_op: VSub_Pound
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1361 1367]
                ) (Lit_Other "]") (Lit_Other "=") (DQ ($ VSub_Name "$_Dbg_cmd") (" ") ($ VSub_Name "$_Dbg_args"))
              }
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:_Dbg_hi)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Name _Dbg_history>
                        prefix_op: VSub_Pound
                        bracket_op: (WholeArray op_id:Lit_At)
                        spids: [1379 1385]
                      )
                    }
                  spids: [1378]
                )
              ]
              spids: [1378]
            )
            (C {(history)} {(-s)} {(--)} {(DQ ($ VSub_Name "$full_cmd"))})
            (C {(typeset)} {(-i)} {(Lit_VarLike "_Dbg_redo=") (1)})
            (While
              cond: [
                (Sentence
                  child: (DParen child:(ArithVarRef name:_Dbg_redo))
                  terminator: <Op_Semi ";">
                )
              ]
              body: 
                (DoGroup
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:_Dbg_redo)
                          op: Equal
                          rhs: {(0)}
                          spids: [1423]
                        )
                      ]
                      spids: [1423]
                    )
                    (AndOr
                      children: [
                        (DBracket
                          expr: (BoolUnary op_id:BoolUnary_z child:{($ VSub_Name "$_Dbg_cmd")})
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:_Dbg_cmd)
                              op: Equal
                              rhs: {($ VSub_Name "$_Dbg_last_cmd")}
                              spids: [1438]
                            )
                          ]
                          spids: [1438]
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: (BoolUnary op_id:BoolUnary_n child:{($ VSub_Name "$_Dbg_cmd")})
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(typeset)} {(-i)} {(Lit_VarLike "found=") (0)})
                            (C {(typeset)} {(found_cmd)})
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DBracket
                                          expr: 
                                            (BoolUnary
                                              op_id: BoolUnary_n
                                              child: 
                                                {
                                                  (BracedVarSub
                                                    token: <VSub_Name _Dbg_debugger_commands>
                                                    bracket_op: 
                                                      (ArrayIndex
                                                        expr: (ArithWord w:{($ VSub_Name "$_Dbg_cmd")})
                                                      )
                                                    spids: [1476 1481]
                                                  )
                                                }
                                            )
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:found)
                                          op: Equal
                                          rhs: {(1)}
                                          spids: [1490]
                                        )
                                      ]
                                      spids: [1490]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:found_cmd)
                                          op: Equal
                                          rhs: {($ VSub_Name "$_Dbg_cmd")}
                                          spids: [1494]
                                        )
                                      ]
                                      spids: [1494]
                                    )
                                  ]
                                  spids: [-1 1487]
                                )
                              ]
                              else_action: [
                                (C {(typeset)} {(-i)} {(Lit_VarLike "count=") (0)})
                                (Sentence
                                  child: (C {(typeset)} {(list)})
                                  terminator: <Op_Semi ";">
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:list)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (BracedVarSub
                                              token: <VSub_Name _Dbg_debugger_commands>
                                              prefix_op: VSub_Bang
                                              bracket_op: (WholeArray op_id:Lit_At)
                                              spids: [1520 1526]
                                            )
                                          )
                                        }
                                      spids: [1518]
                                    )
                                  ]
                                  spids: [1518]
                                )
                                (ForEach
                                  iter_name: try
                                  iter_words: [{($ VSub_Name "$list")}]
                                  do_arg_iter: False
                                  body: 
                                    (DoGroup
                                      children: [
                                        (If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (Sentence
                                                  child: 
                                                    (DBracket
                                                      expr: 
                                                        (BoolBinary
                                                          op_id: BoolBinary_EqualTilde
                                                          left: {($ VSub_Name "$try")}
                                                          right: 
                                                            {(Lit_Other "^") 
                                                              ($ VSub_Name "$_Dbg_cmd")
                                                            }
                                                        )
                                                    )
                                                  terminator: <Op_Semi ";">
                                                )
                                              ]
                                              action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:found_cmd)
                                                      op: Equal
                                                      rhs: {($ VSub_Name "$try")}
                                                      spids: [1561]
                                                    )
                                                  ]
                                                  spids: [1561]
                                                )
                                                (DParen
                                                  child: 
                                                    (UnaryAssign
                                                      op_id: Node_PostDPlus
                                                      child: (LhsName name:count)
                                                    )
                                                )
                                              ]
                                              spids: [-1 1558]
                                            )
                                          ]
                                          spids: [-1 1572]
                                        )
                                      ]
                                      spids: [1540 1575]
                                    )
                                  spids: [1535 1538]
                                )
                                (DParen
                                  child: 
                                    (BinaryAssign
                                      op_id: Arith_Equal
                                      left: (LhsName name:found)
                                      right: 
                                        (ArithBinary
                                          op_id: Arith_DEqual
                                          left: (ArithVarRef name:count)
                                          right: (ArithWord w:{(Lit_Digits 1)})
                                        )
                                    )
                                )
                              ]
                              spids: [1498 1590]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (DParen child:(ArithVarRef name:found))
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (C 
                                      {
                                        (BracedVarSub
                                          token: <VSub_Name _Dbg_debugger_commands>
                                          bracket_op: 
                                            (ArrayIndex
                                              expr: (ArithWord w:{($ VSub_Name "$found_cmd")})
                                            )
                                          spids: [1604 1609]
                                        )
                                      } {($ VSub_Name "$_Dbg_args")}
                                    )
                                    (Sentence
                                      child: 
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:IFS)
                                              op: Equal
                                              rhs: {($ VSub_Name "$_Dbg_space_IFS")}
                                              spids: [1614]
                                            )
                                          ]
                                          spids: [1614]
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                    (C {(eval)} {(DQ ("_Dbg_prompt=") ($ VSub_Name "$_Dbg_prompt_str"))})
                                    (AndOr
                                      children: [
                                        (DParen
                                          child: 
                                            (ArithBinary
                                              op_id: Arith_GreatEqual
                                              left: (ArithVarRef name:_Dbg_continue_rc)
                                              right: (ArithWord w:{(Lit_Digits 0)})
                                            )
                                        )
                                        (ControlFlow
                                          token: <ControlFlow_Return return>
                                          arg_word: {($ VSub_Name "$_Dbg_continue_rc")}
                                        )
                                      ]
                                      op_id: Op_DAmp
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [-1 1601]
                                )
                              ]
                              spids: [-1 1646]
                            )
                          ]
                          spids: [-1 1454]
                        )
                      ]
                      spids: [-1 1649]
                    )
                    (Case
                      to_match: {($ VSub_Name "$_Dbg_cmd")}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Other "[") (Lit_Pound "#") (Lit_Other "]") (Lit_Other "*")}]
                          action: [
                            (C {(_Dbg_history_remove_item)})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:_Dbg_last_cmd)
                                  op: Equal
                                  rhs: {(SQ <"#">)}
                                  spids: [1676]
                                )
                              ]
                              spids: [1676]
                            )
                          ]
                          spids: [1665 1670 1682 -1]
                        )
                        (case_arm
                          pat_list: [{(.)}]
                          action: [
                            (C {(_Dbg_list)} {($ VSub_Name "$_Dbg_frame_last_filename")} 
                              {($ VSub_Name "$_Dbg_frame_last_lineno")} {(1)}
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:_Dbg_last_cmd)
                                  op: Equal
                                  rhs: {(SQ <list>)}
                                  spids: [1704]
                                )
                              ]
                              spids: [1704]
                            )
                          ]
                          spids: [1690 1692 1710 -1]
                        )
                        (case_arm
                          pat_list: [{(/) (Lit_Other "*")}]
                          action: [
                            (C {(_Dbg_do_search)} {($ VSub_Name "$_Dbg_cmd")})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:_Dbg_last_cmd)
                                  op: Equal
                                  rhs: {(SQ <search>)}
                                  spids: [1729]
                                )
                              ]
                              spids: [1729]
                            )
                          ]
                          spids: [1718 1721 1735 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "[") (Lit_Other "?") (Lit_Other "]") (Lit_Other "*")}]
                          action: [
                            (C {(_Dbg_do_reverse)} {($ VSub_Name "$_Dbg_cmd")})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:_Dbg_last_cmd)
                                  op: Equal
                                  rhs: {(DQ (reverse))}
                                  spids: [1756]
                                )
                              ]
                              spids: [1756]
                            )
                          ]
                          spids: [1743 1748 1762 -1]
                        )
                        (case_arm
                          pat_list: [{(cd)}]
                          action: [
                            (Assignment
                              keyword: Assign_Local
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:cd_command)
                                  op: Equal
                                  rhs: {(DQ ("cd ") ($ VSub_Name "$_Dbg_args"))}
                                  spids: [1785]
                                )
                              ]
                              spids: [1783]
                            )
                            (C {(eval)} {($ VSub_Name "$cd_command")})
                            (C {(_Dbg_do_pwd)})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:_Dbg_last_cmd)
                                  op: Equal
                                  rhs: {(SQ <cd>)}
                                  spids: [1800]
                                )
                              ]
                              spids: [1800]
                            )
                          ]
                          spids: [1770 1772 1806 -1]
                        )
                        (case_arm
                          pat_list: [{(comp)} {(compl)} {(comple)} {(complet)} {(complete)}]
                          action: [
                            (C {(_Dbg_do_complete)} {($ VSub_Name "$_Dbg_args")})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:_Dbg_last_cmd)
                                  op: Equal
                                  rhs: {(SQ <complete>)}
                                  spids: [1840]
                                )
                              ]
                              spids: [1840]
                            )
                          ]
                          spids: [1814 1832 1846 -1]
                        )
                        (case_arm
                          pat_list: [{(debug)}]
                          action: [
                            (C {(_Dbg_do_debug)} {($ VSub_Name "$_Dbg_args")})
                            (C {(_Dbg_do_next_skip)} {(SQ <skip>)} {(1)})
                            (Sentence
                              child: 
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:IFS)
                                      op: Equal
                                      rhs: {(DQ ($ VSub_Name "$_Dbg_old_IFS"))}
                                      spids: [1877]
                                    )
                                  ]
                                  spids: [1877]
                                )
                              terminator: <Op_Semi ";">
                            )
                            (ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(1)}
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:_Dbg_last_cmd)
                                  op: Equal
                                  rhs: {(SQ <debug>)}
                                  spids: [1889]
                                )
                              ]
                              spids: [1889]
                            )
                          ]
                          spids: [1854 1856 1895 -1]
                        )
                        (case_arm
                          pat_list: [{(D)} {(deletea)} {(deleteal)} {(deleteall)}]
                          action: [
                            (C {(_Dbg_clear_all_brkpt)})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:_Dbg_last_cmd)
                                  op: Equal
                                  rhs: {(SQ <deleteall>)}
                                  spids: [1923]
                                )
                              ]
                              spids: [1923]
                            )
                          ]
                          spids: [1903 1917 1929 -1]
                        )
                        (case_arm
                          pat_list: [{(ControlFlow_Return return)}]
                          spids: [1937 1939 1942 -1]
                        )
                        (case_arm
                          pat_list: [{(shell)} {(SQ <"!!">)}]
                          action: [(C {(eval)} {($ VSub_Name "$_Dbg_args")})]
                          spids: [1950 1958 1965 -1]
                        )
                        (case_arm
                          pat_list: [{(si)} {(sig)} {(sign)} {(signa)} {(signal)}]
                          action: [
                            (C {(_Dbg_do_signal)} {($ VSub_Name "$_Dbg_args")})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:_Dbg_last_cmd)
                                  op: Equal
                                  rhs: {(SQ <signal>)}
                                  spids: [1999]
                                )
                              ]
                              spids: [1999]
                            )
                          ]
                          spids: [1973 1991 2005 -1]
                        )
                        (case_arm
                          pat_list: [{(SQ <"step+">)} {(SQ <step->)}]
                          action: [
                            (C {(_Dbg_do_step)} {(DQ ($ VSub_Name "$_Dbg_cmd"))} 
                              {($ VSub_Name "$_Dbg_args")}
                            )
                            (ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                          spids: [2014 2023 2040 -1]
                        )
                        (case_arm
                          pat_list: [{(L)}]
                          action: [
                            (C {(_Dbg_do_list_brkpt)})
                            (C {(_Dbg_list_watch)})
                            (C {(_Dbg_list_action)})
                          ]
                          spids: [2066 2068 2080 -1]
                        )
                        (case_arm
                          pat_list: [{(A)}]
                          action: [(C {(_Dbg_do_clear_all_actions)} {($ VSub_Name "$_Dbg_args")})]
                          spids: [2088 2090 2098 -1]
                        )
                        (case_arm
                          pat_list: [{(H)}]
                          action: [
                            (C {(_Dbg_history_remove_item)})
                            (C {(_Dbg_do_history_list)} {($ VSub_Name "$_Dbg_args")})
                          ]
                          spids: [2106 2108 2119 -1]
                        )
                        (case_arm
                          pat_list: [{(S)}]
                          action: [(C {(_Dbg_do_list_functions)} {($ VSub_Name "$_Dbg_args")})]
                          spids: [2127 2129 2137 -1]
                        )
                        (case_arm
                          pat_list: [{(V)}]
                          action: [(C {(_Dbg_do_info_variables)} {(DQ ($ VSub_Name "$_Dbg_args"))})]
                          spids: [2145 2147 2157 -1]
                        )
                        (case_arm
                          pat_list: [
                            {(EscapedLiteralPart token:<Lit_EscapedChar "\\!">) (Lit_Other "*")}
                            {(history)}
                          ]
                          action: [(C {(_Dbg_do_history)} {($ VSub_Name "$_Dbg_args")})]
                          spids: [2169 2176 2184 -1]
                        )
                        (case_arm
                          pat_list: [{(SQ )}]
                          action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (DBracket
                                          expr: 
                                            (BoolUnary
                                              op_id: BoolUnary_n
                                              child: {($ VSub_Name "$_Dbg_last_cmd")}
                                            )
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:_Dbg_cmd)
                                          op: Equal
                                          rhs: {($ VSub_Name "$_Dbg_last_cmd")}
                                          spids: [2213]
                                        )
                                      ]
                                      spids: [2213]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:_Dbg_redo)
                                          op: Equal
                                          rhs: {(1)}
                                          spids: [2217]
                                        )
                                      ]
                                      spids: [2217]
                                    )
                                  ]
                                  spids: [-1 2210]
                                )
                              ]
                              spids: [-1 2221]
                            )
                          ]
                          spids: [-1 2191 2224 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: (DParen child:(ArithVarRef name:_Dbg_set_autoeval))
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (C {(_Dbg_do_eval)} {($ VSub_Name "$_Dbg_cmd")} 
                                      {($ VSub_Name "$_Dbg_args")}
                                    )
                                  ]
                                  spids: [-1 2244]
                                )
                              ]
                              else_action: [
                                (C {(_Dbg_undefined_cmd)} {(DQ ($ VSub_Name "$_Dbg_cmd"))})
                                (C {(_Dbg_history_remove_item)})
                              ]
                              spids: [2254 2275]
                            )
                          ]
                          spids: [2227 2229 2278 -1]
                        )
                      ]
                      spids: [1653 1657 2281]
                    )
                  ]
                  spids: [1419 2284]
                )
            )
            (Sentence
              child: 
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:IFS)
                      op: Equal
                      rhs: {($ VSub_Name "$_Dbg_space_IFS")}
                      spids: [2291]
                    )
                  ]
                  spids: [2291]
                )
              terminator: <Op_Semi ";">
            )
            (C {(eval)} {(DQ ("_Dbg_prompt=") ($ VSub_Name "$_Dbg_prompt_str"))})
          ]
          spids: [1181]
        )
      spids: [1177 1180]
    )
    (FuncDef
      name: _Dbg_preloop
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (DParen child:(ArithVarRef name:_Dbg_set_annotate))
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(_Dbg_annotation)} {(SQ <breakpoints>)} {(_Dbg_do_info)} {(breakpoints)})
                    (C {(_Dbg_annotation)} {(SQ <stack>)} {(_Dbg_do_backtrace)} {(3)})
                  ]
                  spids: [-1 2322]
                )
              ]
              spids: [-1 2351]
            )
          ]
          spids: [2310]
        )
      spids: [2306 2309]
    )
    (FuncDef
      name: _Dbg_postcmd
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (DParen child:(ArithVarRef name:_Dbg_set_annotate))
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Case
                      to_match: {($ VSub_Name "$_Dbg_last_cmd")}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(ControlFlow_Break break)}
                            {(tbreak)}
                            {(disable)}
                            {(enable)}
                            {(condition)}
                            {(clear)}
                            {(delete)}
                          ]
                          action: [
                            (C {(_Dbg_annotation)} {(SQ <breakpoints>)} {(_Dbg_do_info)} {(breakpoints)})
                          ]
                          spids: [2382 2408 2422 -1]
                        )
                        (case_arm
                          pat_list: [{(up)} {(down)} {(frame)}]
                          action: [(C {(_Dbg_annotation)} {(SQ <stack>)} {(_Dbg_do_backtrace)} {(3)})]
                          spids: [2425 2435 2449 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          spids: [2452 2454 -1 2457]
                        )
                      ]
                      spids: [2375 2379 2457]
                    )
                  ]
                  spids: [-1 2372]
                )
              ]
              spids: [-1 2460]
            )
          ]
          spids: [2360]
        )
      spids: [2356 2359]
    )
  ]
)