(command.CommandList
  children: [
    (C {<typeset>} {<-A>} {<_Dbg_command_help>})
    (C {<export>} {<_Dbg_command_help>})
    (C {<typeset>} {<-a>} 
      {<Id.Lit_VarLike '_Dbg_command_names_sorted='> (sh_array_literal left:<Id.Op_LParen _>)}
    )
    (C {<typeset>} {<-A>} {<_Dbg_debugger_commands>})
    (command.ShFunction
      name: _Dbg_help_add
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe Id.Op_DAmp]
              children: [
                (command.DParen
                  child: 
                    (arith_expr.Binary
                      op_id: Id.Arith_Less
                      left: {($ Id.VSub_Pound '$#')}
                      right: {<Id.Lit_Digits 2>}
                    )
                )
                (command.DParen
                  child: 
                    (arith_expr.Binary
                      op_id: Id.Arith_Great
                      left: {($ Id.VSub_Pound '$#')}
                      right: {<Id.Lit_Digits 4>}
                    )
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<1>}
                )
              ]
            )
            (command.Sentence
              child: (C {<typeset>} {<-i>} {<add_command>})
              terminator: <Id.Op_Semi _>
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:add_command)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Number 3>
                        suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:{<1>})
                      )
                    }
                  spids: [146]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.IndexedName name:_Dbg_command_help index:{($ Id.VSub_Number '$1')})
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number '$2'))}
                  spids: [154]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DParen child:<Id.Lit_ArithVarLike add_command>)
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: 
                        (sh_lhs_expr.IndexedName
                          name: _Dbg_debugger_commands
                          index: {($ Id.VSub_Number '$1')}
                        )
                      op: assign_op.Equal
                      rhs: {(DQ <_Dbg_do_> ($ Id.VSub_Number '$1'))}
                      spids: [173]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DParen
                              child: 
                                (arith_expr.Binary
                                  op_id: Id.Arith_DEqual
                                  left: {($ Id.VSub_Pound '$#')}
                                  right: {<Id.Lit_Digits 4>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<complete>} {<-F>} {(DQ ($ Id.VSub_Number '$4'))} {(DQ ($ Id.VSub_Number '$1'))})
                  ]
                  spids: [184 196]
                )
              ]
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_help_add_sub
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:add_command)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Number 4>
                        suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:{<1>})
                      )
                    }
                  spids: [232]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp]
              children: [
                (command.DParen
                  child: 
                    (arith_expr.Binary
                      op_id: Id.Arith_NEqual
                      left: {($ Id.VSub_Pound '$#')}
                      right: {<Id.Lit_Digits 3>}
                    )
                )
                (command.DParen
                  child: 
                    (arith_expr.Binary
                      op_id: Id.Arith_NEqual
                      left: {($ Id.VSub_Pound '$#')}
                      right: {<Id.Lit_Digits 4>}
                    )
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<1>}
                )
              ]
            )
            (C {<eval>} 
              {
                (DQ <_Dbg_command_help_> ($ Id.VSub_Number '$1') <'['> ($ Id.VSub_Number '$2') <']='> 
                  (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) ($ Id.VSub_Number '$3') (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>)
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (command.DParen child:<Id.Lit_ArithVarLike add_command>)
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<eval>} 
                      {
                        (DQ <_Dbg_debugger_> (${ Id.VSub_Number 1) <'_commands['> 
                          ($ Id.VSub_Number '$2') <']='> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) <_Dbg_do_> (${ Id.VSub_Number 1) <_> 
                          (${ Id.VSub_Number 2) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>)
                        )
                      }
                    )
                  ]
                  spids: [281 292]
                )
              ]
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_help_sort_command_names
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DParen
                  child: 
                    (arith_expr.Binary
                      op_id: Id.Arith_Great
                      left: 
                        {
                          (braced_var_sub
                            token: <Id.VSub_Name _Dbg_command_names_sorted>
                            prefix_op: (Id.VSub_Pound)
                          )
                        }
                      right: {<Id.Lit_Digits 0>}
                    )
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<0>}
                )
              ]
            )
            (C {<typeset>} {<-a>} {<list>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:list)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (sh_array_literal
                        left: <Id.Op_LParen _>
                        words: [
                          {
                            (DQ 
                              (braced_var_sub
                                token: <Id.VSub_Name _Dbg_command_help>
                                prefix_op: (Id.VSub_Bang)
                                bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                              )
                            )
                          }
                        ]
                      )
                    }
                  spids: [363]
                )
              ]
            )
            (C {<sort_list>} {<0>} 
              {
                (braced_var_sub
                  token: <Id.VSub_Name list>
                  prefix_op: (Id.VSub_Pound)
                  bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                ) <-1>
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_Dbg_sorted_command_names)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (sh_array_literal
                        left: <Id.Op_LParen _>
                        words: [
                          {
                            (DQ 
                              (braced_var_sub
                                token: <Id.VSub_Name list>
                                bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                              )
                            )
                          }
                        ]
                      )
                    }
                  spids: [391]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_help_set
      body: 
        (BraceGroup
          children: [
            (C {<typeset>} {<subcmd>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DParen
                              child: 
                                (arith_expr.Binary
                                  op_id: Id.Arith_DEqual
                                  left: {($ Id.VSub_Pound '$#')}
                                  right: {<Id.Lit_Digits 0>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<typeset>} {<-a>} {<list>})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:list)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (sh_array_literal
                                left: <Id.Op_LParen _>
                                words: [
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name _Dbg_command_help_set>
                                        prefix_op: (Id.VSub_Bang)
                                        bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                      )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [444]
                        )
                      ]
                    )
                    (C {<sort_list>} {<0>} 
                      {
                        (braced_var_sub
                          token: <Id.VSub_Name list>
                          prefix_op: (Id.VSub_Pound)
                          bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                        ) <-1>
                      }
                    )
                    (command.ForEach
                      iter_name: subcmd
                      iter_words: [
                        {
                          (braced_var_sub
                            token: <Id.VSub_Name list>
                            bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                          )
                        }
                      ]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [(C {<_Dbg_help_set>} {($ Id.VSub_DollarName '$subcmd')} {<1>})]
                        )
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [419 434]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:subcmd)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number '$1'))}
                  spids: [508]
                )
              ]
            )
            (C {<typeset>} {<Id.Lit_VarLike 'label='> (DQ ($ Id.VSub_Number '$2'))})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_n
                                  child: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Name _Dbg_command_help_set>
                                          bracket_op: 
                                            (bracket_op.ArrayIndex
                                              expr: {($ Id.VSub_DollarName '$subcmd')}
                                            )
                                        )
                                      )
                                    }
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: {($ Id.VSub_DollarName '$label')}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<_Dbg_msg_rst>} 
                              {
                                (DQ 
                                  (braced_var_sub
                                    token: <Id.VSub_Name _Dbg_command_help_set>
                                    bracket_op: 
                                      (bracket_op.ArrayIndex
                                        expr: {($ Id.VSub_DollarName '$subcmd')}
                                      )
                                  )
                                )
                              }
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<0>}
                            )
                          ]
                          spids: [545 557]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:label)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<builtin>} {<printf>} {(DQ <'set %-12s-- '>)} 
                                        {($ Id.VSub_DollarName '$subcmd')}
                                      )
                                  )
                                }
                              spids: [580]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [523 542]
                )
              ]
            )
            (command.Case
              to_match: {($ Id.VSub_DollarName '$subcmd')}
              arms: [
                (case_arm
                  pat_list: [{<ar>} {<arg>} {<args>}]
                  action: [
                    (C {<_Dbg_msg>} 
                      {
                        (DQ (${ Id.VSub_Name label) 
                          <'Set argument list to give program when restarted.'>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [608 618 638 -1]
                )
                (case_arm
                  pat_list: [{<an>} {<ann>} {<anno>} {<annot>} {<annota>} {<annotat>} {<annotate>}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: {($ Id.VSub_DollarName '$label')}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<typeset>} 
                              {<Id.Lit_VarLike 'post_label='> 
                                (SQ <'\n'> 
                                  <
'0 == normal;     1 == fullname (for use when running under emacs).'
                                  >
                                )
                              }
                            )
                          ]
                          spids: [670 682]
                        )
                      ]
                    )
                    (C {<_Dbg_msg>} 
                      {
                        (DQ (${ Id.VSub_Name label) <'Set annotation level.'> 
                          ($ Id.VSub_DollarName '$post_label')
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [641 667 715 -1]
                )
                (case_arm
                  pat_list: [{<autoe>} {<autoev>} {<autoeva>} {<autoeval>}]
                  action: [
                    (C {<_Dbg_help_set_onoff>} {(SQ <autoeval>)} {(SQ <autoeval>)} 
                      {(DQ <'Evaluate unrecognized commands'>)}
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [718 732 757 -1]
                )
                (case_arm
                  pat_list: [{<autol>} {<autoli>} {<autolis>} {<autolist>}]
                  action: [
                    (C {<typeset>} {<Id.Lit_VarLike 'onoff='> (DQ <on.>)})
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_z
                              child: 
                                {
                                  (braced_var_sub
                                    token: <Id.VSub_Name _Dbg_cmdloop_hooks>
                                    bracket_op: (bracket_op.ArrayIndex expr:{(SQ <list>)})
                                  )
                                }
                            )
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:onoff)
                              op: assign_op.Equal
                              rhs: {(SQ <off.>)}
                              spids: [802]
                            )
                          ]
                        )
                      ]
                    )
                    (C {<_Dbg_msg>} 
                      {(DQ (${ Id.VSub_Name label) <'Run list command is '> (${ Id.VSub_Name onoff))}
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [760 774 828 -1]
                )
                (case_arm
                  pat_list: [{<b>} {<ba>} {<bas>} {<base>} {<basen>} {<basena>} {<basenam>} {<basename>}]
                  action: [
                    (C {<_Dbg_help_set_onoff>} {(SQ <basename>)} {(SQ <basename>)} 
                      {(DQ <'Set short filenames (the basename) in debug output'>)}
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [831 861 886 -1]
                )
                (case_arm
                  pat_list: [{<de>} {<deb>} {<debu>} {<debug>}]
                  action: [
                    (C {<_Dbg_help_set_onoff>} {(SQ <debug>)} {(SQ <debug>)} 
                      {(DQ <'Set debugging the debugger'>)}
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [889 897 922 -1]
                )
                (case_arm
                  pat_list: [{<di>} {<dif>} {<diff>} {<diffe>} {<differe>} {<differen>} {<different>}]
                  action: [
                    (C {<typeset>} 
                      {<Id.Lit_VarLike 'onoff='> 
                        (braced_var_sub
                          token: <Id.VSub_Number 1>
                          suffix_op: 
                            (suffix_op.Unary
                              tok: <Id.VTest_ColonHyphen ':-'>
                              arg_word: {(SQ <on>)}
                            )
                        )
                      }
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DParen
                          child: <Id.Lit_ArithVarLike _Dbg_set_different>
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:onoff)
                              op: assign_op.Equal
                              rhs: {(SQ <on.>)}
                              spids: [963]
                            )
                          ]
                        )
                      ]
                    )
                    (C {<_Dbg_msg>} 
                      {(DQ (${ Id.VSub_Name label) <'Set to stop at a different line is'>)} {($ Id.VSub_DollarName '$onoff')}
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [925 939 988 -1]
                )
                (case_arm
                  pat_list: [{<Id.KW_Do do>} {<doll>} {<dolla>} {<dollar>} {<dollar0>}]
                  action: [
                    (C {<_Dbg_msg>} 
                      {
                        (DQ (${ Id.VSub_Name label) <'Set '> 
                          (word_part.EscapedLiteral
                            token: <Id.Lit_EscapedChar '\\$'>
                          ) <0>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [991 1001 1021 -1]
                )
                (case_arm
                  pat_list: [{<e>} {<ed>} {<edi>} {<edit>} {<editi>} {<editin>} {<editing>}]
                  action: [
                    (C {<_Dbg_msg_nocr>} 
                      {
                        (DQ (${ Id.VSub_Name label) 
                          <'Set editing of command lines as they are typed is '>
                        )
                      }
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: {($ Id.VSub_DollarName '$_Dbg_edit')}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<_Dbg_msg>} {(SQ <off.>)})]
                          spids: [1065 1077]
                        )
                      ]
                      else_action: [(C {<_Dbg_msg>} {(SQ <on.>)})]
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [1024 1050 1105 -1]
                )
                (case_arm
                  pat_list: [{<high>} {<highl>} {<highlight>}]
                  action: [
                    (C {<_Dbg_msg_nocr>} 
                      {
                        (DQ (${ Id.VSub_Name label) <'Set syntax highlighting of source listings is '>)
                      }
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: {($ Id.VSub_DollarName '$_Dbg_edit')}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<_Dbg_msg>} {(SQ <off.>)})]
                          spids: [1133 1145]
                        )
                      ]
                      else_action: [(C {<_Dbg_msg>} {(SQ <on.>)})]
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [1108 1118 1173 -1]
                )
                (case_arm
                  pat_list: [{<his>} {<hist>} {<history>}]
                  action: [
                    (C {<_Dbg_msg_nocr>} 
                      {(DQ (${ Id.VSub_Name label) <'Set record command history is '>)}
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: {($ Id.VSub_DollarName '$_Dbg_set_edit')}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<_Dbg_msg>} {(SQ <off.>)})]
                          spids: [1201 1213]
                        )
                      ]
                      else_action: [(C {<_Dbg_msg>} {(SQ <on.>)})]
                    )
                  ]
                  spids: [1176 1186 1236 -1]
                )
                (case_arm
                  pat_list: [{<si>} {<siz>} {<size>}]
                  action: [
                    (C {<eval>} {(DQ ($ Id.VSub_DollarName '$_seteglob'))})
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: {($ Id.VSub_Number '$2')}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<_Dbg_errmsg>} {(DQ <'Argument required (integer to set it to.).'>)})
                          ]
                          spids: [1259 1271]
                        )
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobNEqual
                                          left: {($ Id.VSub_Number '$2')}
                                          right: {($ Id.VSub_DollarName '$int_pat')}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<_Dbg_errmsg>} 
                              {(DQ <'Integer argument expected; got: '> ($ Id.VSub_Number '$2'))}
                            )
                            (C {<eval>} {(DQ ($ Id.VSub_DollarName '$_resteglob'))})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<1>}
                            )
                          ]
                          spids: [1281 1295]
                        )
                      ]
                    )
                    (C {<eval>} {(DQ ($ Id.VSub_DollarName '$_resteglob'))})
                    (C {<_Dbg_write_journal_eval>} 
                      {(DQ <'_Dbg_history_length='> ($ Id.VSub_Number '$2'))}
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [1239 1249 1341 -1]
                )
                (case_arm
                  pat_list: [{<lin>} {<line>} {<linet>} {<linetr>} {<linetra>} {<linetrac>} {<linetrace>}]
                  action: [
                    (C {<typeset>} {<Id.Lit_VarLike 'onoff='> (SQ <off.>)})
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DParen
                          child: <Id.Lit_ArithVarLike _Dbg_set_linetrace>
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:onoff)
                              op: assign_op.Equal
                              rhs: {(SQ <on.>)}
                              spids: [1390]
                            )
                          ]
                        )
                      ]
                    )
                    (C {<_Dbg_msg>} 
                      {
                        (DQ (${ Id.VSub_Name label) 
                          <'Set tracing execution of lines before executed is'>
                        )
                      } {($ Id.VSub_DollarName '$onoff')}
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DParen
                                      child: <Id.Lit_ArithVarLike _Dbg_set_linetrace>
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<_Dbg_msg>} 
                              {(DQ <'set linetrace delay -- delay before executing a line is'>)} {($ Id.VSub_DollarName '$_Dbg_set_linetrace_delay')}
                            )
                          ]
                          spids: [1410 1421]
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [1344 1370 1443 -1]
                )
                (case_arm
                  pat_list: [{<lis>} {<list>} {<lists>} {<listsi>} {<listsiz>} {<listsize>}]
                  action: [
                    (C {<_Dbg_msg>} 
                      {
                        (DQ (${ Id.VSub_Name label) <'Set number of source lines '> 
                          ($ Id.VSub_DollarName '$_Dbg_debugger_name') <' will list by default.'>
                        )
                      }
                    )
                  ]
                  spids: [1446 1468 1485 -1]
                )
                (case_arm
                  pat_list: [{<p>} {<pr>} {<pro>} {<prom>} {<promp>} {<prompt>}]
                  action: [
                    (C {<_Dbg_msg>} 
                      {
                        (DQ (${ Id.VSub_Name label) (${ Id.VSub_Name _Dbg_debugger_name) 
                          <'\'s prompt is:'> <Id.Lit_BadBackslash '\\'> <n>
                        )
                      } 
                      {
                        (DQ <'      '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) 
                          ($ Id.VSub_DollarName '$_Dbg_prompt_str') (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) <.>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [1488 1510 1545 -1]
                )
                (case_arm
                  pat_list: [
                    {<sho>}
                    {<show>}
                    {<showc>}
                    {<showco>}
                    {<showcom>}
                    {<showcomm>}
                    {<showcomma>}
                    {<showcomman>}
                    {<showcommand>}
                  ]
                  action: [
                    (C {<_Dbg_msg>} 
                      {
                        (DQ (${ Id.VSub_Name label) <'Set showing the command to execute is '> 
                          ($ Id.VSub_DollarName '$_Dbg_set_show_command') <.>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [1548 1566 1588 -1]
                )
                (case_arm
                  pat_list: [{<sty>} {<style>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_n
                              child: {($ Id.VSub_DollarName '$label')}
                            )
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:label)
                              op: assign_op.Equal
                              rhs: {(SQ <'set style       -- '>)}
                              spids: [1610]
                            )
                          ]
                        )
                      ]
                    )
                    (C {<_Dbg_msg_nocr>} 
                      {(DQ (${ Id.VSub_Name label) <'Set pygments highlighting style is '>)}
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: {($ Id.VSub_DollarName '$_Dbg_set_style')}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<_Dbg_msg>} {(SQ <off.>)})]
                          spids: [1628 1640]
                        )
                      ]
                      else_action: [(C {<_Dbg_msg>} {(DQ (${ Id.VSub_Name _Dbg_set_style))})]
                    )
                  ]
                  spids: [1591 1597 1665 -1]
                )
                (case_arm
                  pat_list: [
                    {<t>}
                    {<tr>}
                    {<tra>}
                    {<trac>}
                    {<trace>}
                    {<trace->}
                    {<tracec>}
                    {<trace-co>}
                    {<trace-com>}
                    {<trace-comm>}
                    {<trace-comma>}
                    {<trace-comman>}
                    {<trace-command>}
                    {<trace-commands>}
                  ]
                  action: [
                    (C {<_Dbg_msg>} 
                      {
                        (DQ (${ Id.VSub_Name label) <'Set showing debugger commands is '> 
                          ($ Id.VSub_DollarName '$_Dbg_set_trace_commands') <.>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [1668 1696 1718 -1]
                )
                (case_arm
                  pat_list: [{<tt>} {<tty>}]
                  action: [
                    (C {<typeset>} {<Id.Lit_VarLike 'dbg_tty='> ($ Id.VSub_DollarName '$_Dbg_tty')})
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_n
                              child: {($ Id.VSub_DollarName '$dbg_tty')}
                            )
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:dbg_tty)
                              op: assign_op.Equal
                              rhs: 
                                {(command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<tty>}))}
                              spids: [1744]
                            )
                          ]
                        )
                      ]
                    )
                    (C {<_Dbg_msg>} 
                      {
                        (DQ (${ Id.VSub_Name label) <'Debugger output goes to '> 
                          ($ Id.VSub_DollarName '$dbg_tty') <.>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [1721 1725 1769 -1]
                )
                (case_arm
                  pat_list: [{<wi>} {<wid>} {<widt>} {<width>}]
                  action: [
                    (C {<_Dbg_msg>} 
                      {
                        (DQ (${ Id.VSub_Name label) <'Set maximum width of lines is '> 
                          ($ Id.VSub_DollarName '$_Dbg_set_linewidth') <.>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [1772 1780 1802 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (C {<_Dbg_errmsg>} 
                      {
                        (DQ <'There is no '> 
                          (word_part.EscapedLiteral
                            token: <Id.Lit_EscapedChar '\\"'>
                          ) <'set '> ($ Id.VSub_DollarName '$subcmd') (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) 
                          <' command.'>
                        )
                      }
                    )
                  ]
                  spids: [1805 1807 -1 1824]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_help_show
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DParen
                              child: 
                                (arith_expr.Binary
                                  op_id: Id.Arith_DEqual
                                  left: {($ Id.VSub_Pound '$#')}
                                  right: {<Id.Lit_Digits 0>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<typeset>} {<-a>} {<list>})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:list)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (sh_array_literal
                                left: <Id.Op_LParen _>
                                words: [
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name _Dbg_command_help_show>
                                        prefix_op: (Id.VSub_Bang)
                                        bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                      )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [1861]
                        )
                      ]
                    )
                    (C {<sort_list>} {<0>} 
                      {
                        (braced_var_sub
                          token: <Id.VSub_Name list>
                          prefix_op: (Id.VSub_Pound)
                          bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                        ) <-1>
                      }
                    )
                    (C {<typeset>} {<subcmd>})
                    (command.ForEach
                      iter_name: subcmd
                      iter_words: [
                        {
                          (braced_var_sub
                            token: <Id.VSub_Name list>
                            bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                          )
                        }
                      ]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobNEqual
                                      left: {($ Id.VSub_DollarName '$subcmd')}
                                      right: {(SQ <version>)}
                                    )
                                )
                                (C {<_Dbg_help_show>} {($ Id.VSub_DollarName '$subcmd')} {<1>})
                              ]
                            )
                          ]
                        )
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [1836 1851]
                )
              ]
            )
            (C {<typeset>} {<Id.Lit_VarLike 'subcmd='> ($ Id.VSub_Number '$1')})
            (C {<typeset>} {<Id.Lit_VarLike 'label='> (DQ ($ Id.VSub_Number '$2'))})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_n
                                  child: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Name _Dbg_command_help_show>
                                          bracket_op: 
                                            (bracket_op.ArrayIndex
                                              expr: {($ Id.VSub_DollarName '$subcmd')}
                                            )
                                        )
                                      )
                                    }
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: {($ Id.VSub_DollarName '$label')}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<_Dbg_msg_rst>} 
                              {
                                (DQ 
                                  (braced_var_sub
                                    token: <Id.VSub_Name _Dbg_command_help_show>
                                    bracket_op: 
                                      (bracket_op.ArrayIndex
                                        expr: {($ Id.VSub_DollarName '$subcmd')}
                                      )
                                  )
                                )
                              }
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<0>}
                            )
                          ]
                          spids: [1981 1993]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:label)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<builtin>} {<printf>} {(DQ <'show %-12s-- '>)} 
                                        {($ Id.VSub_DollarName '$subcmd')}
                                      )
                                  )
                                }
                              spids: [2016]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [1959 1978]
                )
              ]
            )
            (command.Case
              to_match: {($ Id.VSub_DollarName '$subcmd')}
              arms: [
                (case_arm
                  pat_list: [{<al>} {<ali>} {<alia>} {<alias>} {<aliase>} {<aliases>}]
                  action: [
                    (C {<_Dbg_msg>} 
                      {(DQ (${ Id.VSub_Name label) <'Show list of aliases currently in effect.'>)}
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [2044 2066 2086 -1]
                )
                (case_arm
                  pat_list: [{<ar>} {<arg>} {<args>}]
                  action: [
                    (C {<_Dbg_msg>} 
                      {
                        (DQ (${ Id.VSub_Name label) <'Show argument list to give program on restart.'>)
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [2089 2099 2119 -1]
                )
                (case_arm
                  pat_list: [{<an>} {<ann>} {<anno>} {<annot>} {<annota>} {<annotat>} {<annotate>}]
                  action: [
                    (C {<_Dbg_msg>} {(DQ (${ Id.VSub_Name label) <'Show annotation_level'>)})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [2122 2148 2168 -1]
                )
                (case_arm
                  pat_list: [{<autoe>} {<autoev>} {<autoeva>} {<autoeval>}]
                  action: [
                    (C {<_Dbg_msg>} 
                      {(DQ (${ Id.VSub_Name label) <'Show if we evaluate unrecognized commands.'>)}
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [2171 2185 2205 -1]
                )
                (case_arm
                  pat_list: [{<autol>} {<autoli>} {<autolis>} {<autolist>}]
                  action: [
                    (C {<_Dbg_msg>} {(DQ (${ Id.VSub_Name label) <'Run list before command loop?'>)})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [2208 2222 2242 -1]
                )
                (case_arm
                  pat_list: [{<b>} {<ba>} {<bas>} {<base>} {<basen>} {<basena>} {<basenam>} {<basename>}]
                  action: [
                    (C {<_Dbg_msg>} 
                      {
                        (DQ (${ Id.VSub_Name label) 
                          <'Show if we are are to show short or long filenames.'>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [2245 2275 2295 -1]
                )
                (case_arm
                  pat_list: [{<com>} {<comm>} {<comma>} {<comman>} {<command>} {<commands>}]
                  action: [
                    (C {<_Dbg_msg>} 
                      {
                        (DQ (${ Id.VSub_Name label) 
                          <'commands [+|n] -- Show the history of commands you typed.\n'> <'You can supply a command number to start with, or a + to start after\n'> 
                          <'the previous command number shown. A negative number indicates the\n'> <'number of lines to list.'>
                        )
                      }
                    )
                  ]
                  spids: [2298 2320 2338 -1]
                )
                (case_arm
                  pat_list: [{<cop>} {<copy>} {<copyi>} {<copyin>} {<copying>}]
                  action: [
                    (C {<_Dbg_msg>} 
                      {
                        (DQ (${ Id.VSub_Name label) 
                          <'Conditions for redistributing copies of debugger.'>
                        )
                      }
                    )
                  ]
                  spids: [2341 2358 2373 -1]
                )
                (case_arm
                  pat_list: [{<d>} {<de>} {<deb>} {<debu>} {<debug>}]
                  action: [
                    (C {<_Dbg_msg>} 
                      {(DQ (${ Id.VSub_Name label) <'Show if we are set to debug the debugger.'>)}
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [2376 2385 2405 -1]
                )
                (case_arm
                  pat_list: [{<different>} {<force>}]
                  action: [
                    (C {<_Dbg_msg>} 
                      {(DQ (${ Id.VSub_Name label) <'Show if debugger stops at a different line.'>)}
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [2408 2413 2433 -1]
                )
                (case_arm
                  pat_list: [
                    {<dir>}
                    {<dire>}
                    {<direc>}
                    {<direct>}
                    {<directo>}
                    {<director>}
                    {<directori>}
                    {<directorie>}
                    {<directories>}
                  ]
                  action: [
                    (C {<_Dbg_msg>} 
                      {
                        (DQ (${ Id.VSub_Name label) 
                          <'Show file directories searched for listing source.'>
                        )
                      }
                    )
                  ]
                  spids: [2436 2453 2468 -1]
                )
                (case_arm
                  pat_list: [{<editing>}]
                  action: [
                    (C {<_Dbg_msg>} 
                      {(DQ (${ Id.VSub_Name label) <'Show editing of command lines and edit style.'>)}
                    )
                  ]
                  spids: [2471 2473 2488 -1]
                )
                (case_arm
                  pat_list: [{<highlight>}]
                  action: [
                    (C {<_Dbg_msg>} 
                      {(DQ (${ Id.VSub_Name label) <'Show if we syntax highlight source listings.'>)}
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [2491 2493 2513 -1]
                )
                (case_arm
                  pat_list: [{<history>}]
                  action: [
                    (C {<_Dbg_msg>} 
                      {(DQ (${ Id.VSub_Name label) <'Show if we are recording command history.'>)}
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [2516 2518 2538 -1]
                )
                (case_arm
                  pat_list: [{<lin>} {<line>} {<linet>} {<linetr>} {<linetra>} {<linetrac>} {<linetrace>}]
                  action: [
                    (C {<_Dbg_msg>} 
                      {(DQ (${ Id.VSub_Name label) <'Show whether to trace lines before execution.'>)}
                    )
                  ]
                  spids: [2541 2567 2582 -1]
                )
                (case_arm
                  pat_list: [{<lis>} {<list>} {<lists>} {<listsi>} {<listsiz>} {<listsize>}]
                  action: [
                    (C {<_Dbg_msg>} 
                      {
                        (DQ (${ Id.VSub_Name label) 
                          <'Show number of source lines debugger will list by default.'>
                        )
                      }
                    )
                  ]
                  spids: [2585 2607 2622 -1]
                )
                (case_arm
                  pat_list: [{<p>} {<pr>} {<pro>} {<prom>} {<promp>} {<prompt>}]
                  action: [
                    (C {<_Dbg_msg>} {(DQ (${ Id.VSub_Name label) <'Show debugger prompt.'>)})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [2625 2647 2667 -1]
                )
                (case_arm
                  pat_list: [{<sty>} {<style>}]
                  action: [
                    (C {<_Dbg_msg>} 
                      {(DQ <'show style       -- Show pygments style in source-code listings.'>)}
                    )
                  ]
                  spids: [2670 2676 2688 -1]
                )
                (case_arm
                  pat_list: [
                    {<t>}
                    {<tr>}
                    {<tra>}
                    {<trac>}
                    {<trace>}
                    {<trace->}
                    {<trace-c>}
                    {<trace-co>}
                    {<trace-com>}
                    {<trace-comm>}
                    {<trace-comma>}
                    {<trace-comman>}
                    {<trace-command>}
                    {<trace-commands>}
                  ]
                  action: [
                    (C {<_Dbg_msg>} 
                      {(SQ <'show trace-commands -- Show if we are echoing debugger commands.'>)}
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [2691 2719 2736 -1]
                )
                (case_arm
                  pat_list: [{<tt>} {<tty>}]
                  action: [
                    (C {<_Dbg_msg>} {(DQ (${ Id.VSub_Name label) <'Where debugger output goes to.'>)})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [2739 2745 2765 -1]
                )
                (case_arm
                  pat_list: [{<wa>} {<war>} {<warr>} {<warra>} {<warran>} {<warrant>} {<warranty>}]
                  action: [
                    (C {<_Dbg_msg>} 
                      {(DQ (${ Id.VSub_Name label) <'Various kinds of warranty you do not have.'>)}
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [2768 2794 2814 -1]
                )
                (case_arm
                  pat_list: [{<width>}]
                  action: [
                    (C {<_Dbg_msg>} {(DQ (${ Id.VSub_Name label) <'maximum width of a line.'>)})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [2817 2819 2839 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (C {<_Dbg_msg>} 
                      {
                        (DQ <'Undefined show command: '> 
                          (word_part.EscapedLiteral
                            token: <Id.Lit_EscapedChar '\\"'>
                          ) ($ Id.VSub_DollarName '$subcmd') (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) 
                          <'.  Try '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) <'help show'> 
                          (word_part.EscapedLiteral
                            token: <Id.Lit_EscapedChar '\\"'>
                          ) <.>
                        )
                      }
                    )
                  ]
                  spids: [2842 2844 -1 2864]
                )
              ]
            )
          ]
        )
    )
  ]
)