(command.CommandList
  children: [
    (command.ShFunction
      name: _Dbg_usage
      body: 
        (BraceGroup
          children: [
            (C {<printf>} 
              {
                (DQ <'Usage:\n'> <'   '> (${ Id.VSub_Name _Dbg_pname) <' [OPTIONS] <script_file>\n'> 
                  <'\n'> <'Runs '> ($ Id.VSub_DollarName '$_Dbg_shell_name') <' <script_file> under a debugger.\n'> <'\n'> 
                  <'options:\n'> <'    -h | --help              Print this help.\n'> 
                  <'    -q | --quiet             Do not print introductory and quiet messages.\n'> <'    -A | --annotate  LEVEL   Set the annotation level.\n'> 
                  <'    -B | --basename          Show basename only on source file listings.\n'> <'                             (Needed in regression tests)\n'> 
                  <
'    --highlight {dark|light} Use dark or light background ANSI terminal sequence\n'
                  > <'                             syntax highlighting\n'> <'       | --no-highlight\n'> 
                  <'                             Don\'t use ANSI terminal sequences for syntax\n'> <'                             highlight\n'> <'    --highlight | --no-highlight\n'> 
                  <
'                             Use or don\'t use ANSI terminal sequences for syntax\n'
                  > <'                             highlight\n'> 
                  <'    --init-file FILE         Source script file FILE. Similar to bash\'s\n'> <'                             corresponding option. This option can be given\n'> 
                  <'                             several times with different files.\n'> <'    -L | --library DIRECTORY\n'> 
                  <
'                             Set the directory location of library helper file: '
                  > ($ Id.VSub_DollarName '$_Dbg_main') <'\n'> 
                  <'    -c | --command STRING    Run STRING instead of a script file\n'> <'    -n | --nx | --no-init    Don\'t run initialization files.\n'> 
                  <
'    -S | --style STYLE       Run use pygments STYLE for formatting source code\n'
                  > <'    --tty | --terminal DEV   Set to terminal in debugger output to DEV\n'> 
                  <'                             DEV can also be &1 for STDOUT\n'> <'    -T | --tempdir DIRECTORY\n'> 
                  <'                             Use DIRECTORY to store temporary files\n'> <'    -V | --version           Print the debugger version number.\n'> 
                  <'    -X | --trace             Set line tracing similar to set -x\n'> <'    -x | --eval-command CMDFILE\n'> 
                  <'                             Execute debugger commands from CMDFILE.\n'>
                )
              }
            )
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<100>})
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_show_version
      body: 
        (BraceGroup
          children: [
            (C {<printf>} 
              {
                (DQ <'There is absolutely no warranty for '> 
                  ($ Id.VSub_DollarName '$_Dbg_debugger_name') <'.  Type '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) <'show warranty'> 
                  (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) <' for details.\n'>
                )
              }
            )
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<101>})
          ]
        )
    )
    (C {<typeset>} {<-xa>} {<_Dbg_orig_script_args>})
    (C {<eval>} 
      {
        (DQ <'_Dbg_orig_script_args=('> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) 
          (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'@'> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) <')'>
        )
      }
    )
    (C {<typeset>} {<-xa>} {<_Dbg_script_args>})
    (C {<typeset>} {<-i>} {<Id.Lit_VarLike '_Dbg_set_annotate='> <0>})
    (C {<typeset>} {<-i>} {<Id.Lit_VarLike '_Dbg_set_linetrace='> <0>})
    (C {<typeset>} {<-i>} {<Id.Lit_VarLike '_Dbg_set_basename='> <0>})
    (C {<typeset>} {<Id.Lit_VarLike '_Dbg_set_highlight='> (SQ )})
    (command.CommandList
      children: [
        (command.Sentence
          child: (C {<typeset>} {<-a>} {<_Dbg_o_init_files>})
          terminator: <Id.Op_Semi _>
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:_Dbg_o_init_files)
              op: assign_op.Equal
              rhs: {(sh_array_literal left:<Id.Op_LParen _>)}
              spids: [237]
            )
          ]
        )
      ]
    )
    (C {<typeset>} {<-i>} {<Id.Lit_VarLike '_Dbg_o_nx='> <0>})
    (C {<typeset>} {<-ix>} {<_Dbg_working_term_highlight>})
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.Simple
                      words: [{(${ Id.VSub_Name _Dbg_libdir) <'/lib/term-highlight.py'>} {<-V>}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '2>'>
                          loc: (redir_loc.Fd fd:2)
                          arg: {<'/dev/null'>}
                        )
                        (redir
                          op: <Id.Redir_Great '1>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {<'/dev/null'>}
                        )
                      ]
                      do_fork: T
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_Dbg_working_term_highlight)
                  op: assign_op.Equal
                  rhs: {<1>}
                  spids: [276]
                )
              ]
            )
          ]
          spids: [256 273]
        )
      ]
      else_action: [
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:_Dbg_working_term_highlight)
              op: assign_op.Equal
              rhs: {<0>}
              spids: [282]
            )
          ]
        )
      ]
    )
    (C {<typeset>} {<-x>} {<Id.Lit_VarLike '_Dbg_set_style='> (SQ )})
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.DBracket
          expr: (bool_expr.Unary op_id:Id.BoolUnary_z child:{($ Id.VSub_DollarName '$_Dbg_tmpdir')})
        )
        (C {<typeset>} {<Id.Lit_VarLike '_Dbg_tmpdir='> <'/tmp'>})
      ]
    )
    (command.ShFunction
      name: _Dbg_check_tty
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DParen
                  child: 
                    (arith_expr.Binary
                      op_id: Id.Arith_Less
                      left: {($ Id.VSub_Pound '$#')}
                      right: {<Id.Lit_Digits 1>}
                    )
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<1>}
                )
              ]
            )
            (C {<typeset>} {<Id.Lit_VarLike 'tty='> ($ Id.VSub_Number '$1')})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobNEqual
                                  left: {($ Id.VSub_DollarName '$tty')}
                                  right: {(SQ <'&1'>)}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.Pipeline
                                      children: [
                                        (C 
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              child: 
                                                (command.Simple
                                                  words: [{<touch>} {($ Id.VSub_DollarName '$tty')}]
                                                  redirects: [
                                                    (redir
                                                      op: <Id.Redir_Great '>'>
                                                      loc: (redir_loc.Fd fd:1)
                                                      arg: {<'/dev/null'>}
                                                    )
                                                    (redir
                                                      op: <Id.Redir_Great '2>'>
                                                      loc: (redir_loc.Fd fd:2)
                                                      arg: {<'/dev/null'>}
                                                    )
                                                  ]
                                                  do_fork: T
                                                )
                                            )
                                          }
                                        )
                                      ]
                                      negated: T
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<_Dbg_errmsg>} 
                              {
                                (DQ <'Can\'t access '> ($ Id.VSub_DollarName '$tty') <' for writing.'>)
                              }
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<1>}
                            )
                          ]
                          spids: [365 382]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.LogicalNot
                                          child: 
                                            (bool_expr.Unary
                                              op_id: Id.BoolUnary_w
                                              child: {($ Id.VSub_DollarName '$tty')}
                                            )
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<_Dbg_errmsg>} 
                              {(DQ <'tty '> ($ Id.VSub_DollarName '$tty') <' needs to be writable'>)}
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<1>}
                            )
                          ]
                          spids: [402 416]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_Dbg_tty)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$tty')}
                          spids: [436]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_Dbg_prompt_output)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$_Dbg_tty')}
                          spids: [440]
                        )
                      ]
                    )
                  ]
                  spids: [346 362]
                )
              ]
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})
          ]
        )
    )
    (command.ShFunction
      name: _Dbg_parse_options
      body: 
        (BraceGroup
          children: [
            (C {<.>} {(${ Id.VSub_Name _Dbg_libdir) <'/getopts_long.sh'>})
            (C {<typeset>} {<-i>} {<Id.Lit_VarLike '_Dbg_o_quiet='> <0>})
            (C {<typeset>} {<-i>} {<Id.Lit_VarLike '_Dbg_o_version='> <0>})
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (C {<getopts_long>} 
                      {<A> <Id.Lit_Colon ':'> <Bc> <Id.Lit_Colon ':'> <x> <Id.Lit_Colon ':'> <hL> 
                        <Id.Lit_Colon ':'> <nqTt> <Id.Lit_Colon ':'> <VX>
                      } {<opt>} {<annotate>} {<required_argument>} {<basename>} {<no_argument>} {<command>} {<required_argument>} 
                      {<debugger>} {<no_argument>} {<eval-command>} {<required_argument>} {<help>} {<no_argument>} {<highlight>} 
                      {<required_argument>} {<init-file>} {<required_argument>} {<library>} {<required_argument>} {<no-highlight>} {<no_argument>} 
                      {<no-init>} {<no_argument>} {<nx>} {<no_argument>} {<quiet>} {<no_argument>} {<tempdir>} {<required_argument>} {<tty>} 
                      {<required_argument>} {<terminal>} {<required_argument>} {<version>} {<no_argument>} {(SQ )} {(DQ ($ Id.VSub_At '$@'))}
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName '$opt'))}
                      arms: [
                        (case_arm
                          pat_list: [{<A>} {<annotate>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_Dbg_o_annotate)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName '$OPTLARG')}
                                  spids: [639]
                                )
                              ]
                            )
                          ]
                          spids: [630 636 641 -1]
                        )
                        (case_arm
                          pat_list: [{<B>} {<basename>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_Dbg_set_basename)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [653]
                                )
                              ]
                            )
                          ]
                          spids: [644 650 656 -1]
                        )
                        (case_arm
                          pat_list: [{<c>} {<command>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_Dbg_EXECUTION_STRING)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName '$OPTLARG'))}
                                  spids: [668]
                                )
                              ]
                            )
                          ]
                          spids: [659 665 673 -1]
                        )
                        (case_arm
                          pat_list: [{<debugger>}]
                          spids: [676 678 685 -1]
                        )
                        (case_arm
                          pat_list: [{<h>} {<help>}]
                          action: [(C {<_Dbg_usage>})]
                          spids: [688 694 699 -1]
                        )
                        (case_arm
                          pat_list: [{<highlight>}]
                          action: [
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_DollarName '$OPTLARG'))}
                              arms: [
                                (case_arm
                                  pat_list: [{<light>} {<dark>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:_Dbg_set_highlight)
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_DollarName '$OPTLARG')}
                                          spids: [725]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [716 722 729 -1]
                                )
                                (case_arm
                                  pat_list: [{<Id.Lit_Star '*'>}]
                                  action: [
                                    (command.Simple
                                      words: [
                                        {<print>}
                                        {
                                          (DQ <'Expecting \'dark\' or \'light\', got '> 
                                            (word_part.EscapedLiteral
                                              token: <Id.Lit_EscapedChar '\\"'>
                                            ) (${ Id.VSub_Name OPTLARG) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>)
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_GreatAnd '>&'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: {<2>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Exit exit>
                                      arg_word: {<2>}
                                    )
                                  ]
                                  spids: [732 734 -1 757]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.Pipeline
                                              children: [
                                                (command.Subshell
                                                  child: 
                                                    (command.AndOr
                                                      ops: [Id.Op_DPipe]
                                                      children: [
                                                        (C {<pygmentize>} {<--version>})
                                                        (C {<pygmentize>} {<-V>})
                                                      ]
                                                    )
                                                  redirects: [
                                                    (redir
                                                      op: <Id.Redir_Great '2>'>
                                                      loc: (redir_loc.Fd fd:2)
                                                      arg: {<'/dev/null'>}
                                                    )
                                                    (redir
                                                      op: <Id.Redir_Great '1>'>
                                                      loc: (redir_loc.Fd fd:1)
                                                      arg: {<'/dev/null'>}
                                                    )
                                                  ]
                                                )
                                              ]
                                              negated: T
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.Simple
                                      words: [
                                        {<print>}
                                        {(DQ <'Can\'t run pygmentize. --highight forced off'>)}
                                      ]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_GreatAnd '>&'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: {<2>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:_Dbg_set_highlight)
                                          op: assign_op.Equal
                                          rhs: {(SQ )}
                                          spids: [800]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [761 787]
                                )
                              ]
                            )
                          ]
                          spids: [702 704 809 -1]
                        )
                        (case_arm
                          pat_list: [{<no-highlight>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_Dbg_set_highlight)
                                  op: assign_op.Equal
                                  rhs: {(SQ )}
                                  spids: [817]
                                )
                              ]
                            )
                          ]
                          spids: [812 814 821 -1]
                        )
                        (case_arm
                          pat_list: [{<init-file>}]
                          action: [
                            (C {<set>} {<-x>})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_Dbg_o_init_files)
                                  op: assign_op.PlusEqual
                                  rhs: {(DQ ($ Id.VSub_DollarName '$OPTLARG'))}
                                  spids: [834]
                                )
                              ]
                            )
                            (C {<set>} {<Id.Lit_Other '+'> <x>})
                          ]
                          spids: [824 826 846 -1]
                        )
                        (case_arm
                          pat_list: [{<L>} {<library>}]
                          spids: [849 855 857 -1]
                        )
                        (case_arm
                          pat_list: [{<V>} {<version>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_Dbg_o_version)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [869]
                                )
                              ]
                            )
                          ]
                          spids: [860 866 872 -1]
                        )
                        (case_arm
                          pat_list: [{<n>} {<nx>} {<no-init>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_Dbg_o_nx)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [888]
                                )
                              ]
                            )
                          ]
                          spids: [875 885 891 -1]
                        )
                        (case_arm
                          pat_list: [{<q>} {<quiet>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_Dbg_o_quiet)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [903]
                                )
                              ]
                            )
                          ]
                          spids: [894 900 906 -1]
                        )
                        (case_arm
                          pat_list: [{<tempdir>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_Dbg_tmpdir)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName '$OPTLARG')}
                                  spids: [913]
                                )
                              ]
                            )
                          ]
                          spids: [909 910 916 -1]
                        )
                        (case_arm
                          pat_list: [{<terminal>} {<tty>}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<_Dbg_check_tty>} {($ Id.VSub_DollarName '$OPTLARG')})
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:_Dbg_tty)
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_DollarName '$OPTLARG')}
                                          spids: [939]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [928 936]
                                )
                              ]
                              else_action: [(C {<_Dbg_errmsg>} {(SQ <'--tty option ignored'>)})]
                            )
                          ]
                          spids: [919 925 956 -1]
                        )
                        (case_arm
                          pat_list: [{<x>} {<eval-command>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:DBG_INPUT)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName '$OPTLARG')}
                                  spids: [968]
                                )
                              ]
                            )
                          ]
                          spids: [959 965 971 -1]
                        )
                        (case_arm
                          pat_list: [{<X>} {<trace>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_Dbg_set_linetrace)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [983]
                                )
                              ]
                            )
                          ]
                          spids: [974 980 986 -1]
                        )
                        (case_arm
                          pat_list: [{(SQ <'?'>)}]
                          action: [
                            (command.Simple
                              words: [{<echo>} {(SQ <'Use -h or --help to see options.'>)}]
                              redirects: [
                                (redir
                                  op: <Id.Redir_GreatAnd '>&'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {<2>}
                                )
                              ]
                              do_fork: T
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Exit exit>
                              arg_word: {<2>}
                            )
                          ]
                          spids: [989 993 1013 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (command.Simple
                              words: [
                                {<echo>}
                                {
                                  (DQ <'Unknown option '> ($ Id.VSub_DollarName '$opt') 
                                    <'. Use -h or --help to see options.'>
                                  )
                                }
                              ]
                              redirects: [
                                (redir
                                  op: <Id.Redir_GreatAnd '>&'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {<2>}
                                )
                              ]
                              do_fork: T
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Exit exit>
                              arg_word: {<2>}
                            )
                          ]
                          spids: [1016 1018 1037 -1]
                        )
                      ]
                    )
                  ]
                )
            )
            (C {<shift>} 
              {
                (DQ 
                  (word_part.ArithSub
                    anode: 
                      (arith_expr.Binary
                        op_id: Id.Arith_Minus
                        left: {($ Id.VSub_DollarName '$OPTLIND')}
                        right: {<Id.Lit_Digits 1>}
                      )
                  )
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (command.DParen child:<Id.Lit_ArithVarLike _Dbg_o_version>)
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<_Dbg_do_show_version>})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [1061 1072]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DAmp Id.Op_DAmp]
                              children: [
                                (command.DParen
                                  child: 
                                    (arith_expr.Unary
                                      op_id: Id.Arith_Bang
                                      child: <Id.Lit_ArithVarLike _Dbg_o_quiet>
                                    )
                                )
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_n
                                      child: {($ Id.VSub_DollarName '$_Dbg_shell_name')}
                                    )
                                )
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_n
                                      child: {($ Id.VSub_DollarName '$_Dbg_release')}
                                    )
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<echo>} 
                      {
                        (DQ ($ Id.VSub_DollarName '$_Dbg_shell_name') <' debugger, '> 
                          ($ Id.VSub_DollarName '$_Dbg_debugger_name') <', release '> ($ Id.VSub_DollarName '$_Dbg_release')
                        )
                      }
                    )
                    (C {<printf>} 
                      {
                        (SQ <'\n'> 
                          <'Copyright 2002, 2003, 2004, 2006-2012, 2014, 2016 Rocky Bernstein\n'> <'This is free software, covered by the GNU General Public License, and you are\n'> 
                          <
'welcome to change it and/or distribute copies of it under certain conditions.\n'
                          > <'\n'>
                        )
                      }
                    )
                  ]
                  spids: [1083 1118]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DParen child:<Id.Lit_ArithVarLike _Dbg_o_version>)
                (C {<_Dbg_show_version>})
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_n
                                  child: {($ Id.VSub_DollarName '$_Dbg_o_annotate')}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(${ Id.VSub_Name _Dbg_o_annotate)}
                                          right: 
                                            {<Id.Lit_Other '['> <0-9> <Id.Lit_Other ']'> 
                                              <Id.Lit_Other '*'>
                                            }
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_Dbg_set_annotate)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName '$_Dbg_o_annotate')}
                                  spids: [1196]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.DParen
                                              child: 
                                                (arith_expr.Binary
                                                  op_id: Id.Arith_DPipe
                                                  left: 
                                                    (arith_expr.Binary
                                                      op_id: Id.Arith_Great
                                                      left: <Id.Lit_ArithVarLike _Dbg_set_annotate>
                                                      right: {<Id.Lit_Digits 3>}
                                                    )
                                                  right: 
                                                    (arith_expr.Binary
                                                      op_id: Id.Arith_Less
                                                      left: <Id.Lit_ArithVarLike _Dbg_set_annotate>
                                                      right: {<Id.Lit_Digits 0>}
                                                    )
                                                )
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.Simple
                                      words: [
                                        {<echo>}
                                        {
                                          (DQ 
                                            <'Annotation level must be less between 0 and 3. Got: '> ($ Id.VSub_DollarName '$_Dbg_set_annotate') <.>
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_GreatAnd '>&'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: {<2>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                    (command.Simple
                                      words: [{<echo>} {(DQ <'Setting Annotation level to 0.'>)}]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_GreatAnd '>&'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: {<2>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:_Dbg_set_annotate)
                                          op: assign_op.Equal
                                          rhs: {<0>}
                                          spids: [1246]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [1200 1221]
                                )
                              ]
                            )
                          ]
                          spids: [1174 1193]
                        )
                      ]
                      else_action: [
                        (command.Simple
                          words: [
                            {<echo>}
                            {
                              (DQ <'Annotate option should be an integer, got '> 
                                (${ Id.VSub_Name _Dbg_o_annotate) <.>
                              )
                            }
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_GreatAnd '>&'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<2>}
                            )
                          ]
                          do_fork: T
                        )
                        (command.Simple
                          words: [{<echo>} {(DQ <'Setting annotation level to 0.'>)}]
                          redirects: [
                            (redir
                              op: <Id.Redir_GreatAnd '>&'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<2>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                    )
                  ]
                  spids: [1159 1171]
                )
              ]
            )
            (C {<unset>} {<_Dbg_o_annotate>} {<_Dbg_o_version>} {<_Dbg_o_quiet>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_Dbg_script_args)
                  op: assign_op.Equal
                  rhs: {(sh_array_literal left:<Id.Op_LParen _> words:[{(DQ ($ Id.VSub_At '$@'))}])}
                  spids: [1295]
                )
              ]
            )
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.DBracket
                      expr: 
                        (bool_expr.Unary
                          op_id: Id.BoolUnary_n
                          child: {(DQ ($ Id.VSub_DollarName '$_Dbg_dbg_opts_test'))}
                        )
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:OPTLIND)
                  op: assign_op.Equal
                  rhs: {<1>}
                  spids: [1326]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:_Dbg_libdir)
                  op: assign_op.Equal
                  rhs: {(SQ <.>)}
                  spids: [1330]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Unary
                      op_id: Id.BoolUnary_n
                      child: {($ Id.VSub_DollarName '$_Dbg_input')}
                    )
                )
                (C {<typeset>} {<-p>} {<_Dbg_input>})
              ]
            )
            (C {<_Dbg_parse_options>} {(DQ ($ Id.VSub_At '$@'))})
            (C {<typeset>} {<-p>} {<_Dbg_set_highlight>})
            (C {<typeset>} {<-p>} {<_Dbg_set_annotate>})
            (C {<typeset>} {<-p>} {<_Dbg_set_linetrace>})
            (C {<typeset>} {<-p>} {<_Dbg_set_basename>})
          ]
          spids: [1309 1323]
        )
      ]
    )
  ]
)