(command.CommandList
  children: [
    (command.Case
      case_kw: <Id.KW_Case case>
      to_match: 
        (case_arg.Word
          w: {($ Id.VSub_Hyphen -) <Id.Lit_Colon ':'> ($ Id.VSub_DollarName BASH_VERSION)}
        )
      arms_start: <Id.KW_In in>
      arms: [
        (CaseArm
          left: <Id.Lit_Star '*'>
          pattern: 
            (pat.Words
              words: [
                {<Id.Lit_Star '*'> <x> <Id.Lit_Star '*'> <Id.Lit_Colon ':'> <Id.Lit_LBracket '['> 
                  <0123456789> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>
                }
              ]
            )
          middle: <Id.Right_CasePat _>
          action: [
            (command.Sentence
              child: 
                (command.Simple
                  blame_tok: <Id.Lit_Colon ':'>
                  more_env: []
                  words: [
                    {<Id.Lit_Colon ':'>}
                    {<bash>}
                    {<set>}
                    {<-x>}
                    {<is>}
                    {<broken>}
                    {<Id.Lit_Colon ':'>}
                  ]
                  redirects: []
                  do_fork: T
                )
              terminator: <Id.Op_Semi _>
            )
            (command.Simple
              blame_tok: <set>
              more_env: []
              words: [{<set>} {<Id.Lit_Other '+'> <ex>}]
              redirects: []
              do_fork: T
            )
          ]
          right: <Id.Op_DSemi _>
        )
      ]
      arms_end: <Id.KW_Esac esac>
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'command='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'command='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'command='> name:command)
          op: assign_op.Equal
          rhs: {<mamprobe>}
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'opt='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'opt='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'opt='> name:opt)
          op: assign_op.Equal
          rhs: (rhs_word__Empty)
        )
      ]
      redirects: []
    )
    (command.Case
      case_kw: <Id.KW_Case case>
      to_match: 
        (case_arg.Word
          w: 
            {
              (CommandSub
                left_token: <Id.Left_Backtick '`'>
                child: 
                  (command.Subshell
                    left: <Id.Op_LParen _>
                    child: 
                      (command.CommandList
                        children: [
                          (command.Sentence
                            child: 
                              (command.Simple
                                blame_tok: <getopts>
                                more_env: []
                                words: [{<getopts>} {(SQ <'[-][123:xyz]'>)} {<opt>} {<--xyz>}]
                                redirects: []
                                do_fork: T
                              )
                            terminator: <Id.Op_Semi _>
                          )
                          (command.Simple
                            blame_tok: <echo>
                            more_env: []
                            words: [{<echo>} {<0> ($ Id.VSub_DollarName opt)}]
                            redirects: []
                            do_fork: T
                          )
                        ]
                      )
                    right: <Id.Right_Subshell _>
                    redirects: [
                      (Redir
                        op: <Id.Redir_Great '2>'>
                        loc: (redir_loc.Fd fd:2)
                        arg: {<'/dev/null'>}
                      )
                    ]
                  )
                right: <Id.Backtick_Right '`'>
              )
            }
        )
      arms_start: <Id.KW_In in>
      arms: [
        (CaseArm
          left: <0123>
          pattern: (pat.Words words:[{<0123>}])
          middle: <Id.Right_CasePat _>
          action: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'USAGE='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'USAGE='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'USAGE='> name:USAGE)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (SingleQuoted
                        left: <Id.Left_DollarSingleQuote '$\''>
                        tokens: [
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals '[-?\n'>
                          <Id.Char_Literals '@(#)$Id: mamprobe (AT&T Labs Research) 2011-02-11 $\n'>
                          <Id.Char_Literals ']\n'>
                          <Id.Char_Literals '[+NAME?mamprobe - generate MAM cc probe info]\n'>
                          <Id.Char_Literals '[+DESCRIPTION?'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals mamprobe>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' generates MAM (make abstract machine) '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals cc>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1)\n'>
                          <Id.Char_Literals '\tprobe information for use by '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals mamake>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1). '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals cc-path>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ' is the\n'>
                          <Id.Char_Literals '\tabsolute path of the probed compiler and '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals info-file>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ' is where\n'>
                          <Id.Char_Literals '\tthe information is placed. '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals info-file>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ' is usually\n'>
                          <Id.Char_Literals '\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '$INSTALLROOT/lib/probe/C/mam/'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals hash>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ', where '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals hash>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ' is a hash\n'>
                          <Id.Char_Literals '\tof '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals cc-path>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals '. Any '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals info-file>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ' directories are created if needed.\n'>
                          <Id.Char_Literals '\tIf '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals info-file>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ' is '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ->
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' then the probe information is written to\n'>
                          <Id.Char_Literals '\tthe standard output.]\n'>
                          <Id.Char_Literals '[+?'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals mamprobe>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' and '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals mamake>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' are used in the bootstrap phase of\n'>
                          <Id.Char_Literals '\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals package>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) installation before '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals nmake>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) is built. The\n'>
                          <Id.Char_Literals '\tprobed variable names are the '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals nmake>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) names with a '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals mam_>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals '\tprefix, '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals CC>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' converted to '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals cc>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ',  and '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals .>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' converted to '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals _>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '.\n'>
                          <Id.Char_Literals '\tAdditional variables are:]{\n'>
                          <Id.Char_Literals '\t\t[+_hosttype_?the '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals package>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) host type]\n'>
                          <Id.Char_Literals '\t\t[+mam_cc_L?'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -L>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals dir>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ' supported]\n'>
                          <Id.Char_Literals '\t\t[+STDCAT?command to execute for '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals cat>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1); prefixed by\n'>
                          <Id.Char_Literals '\t\t\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals execrate>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) on '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals .exe>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' challenged systems]\n'>
                          <Id.Char_Literals '\t\t[+STDCHMOD?command to execute for '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals chmod>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1); prefixed by\n'>
                          <Id.Char_Literals '\t\t\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals execrate>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) on '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals .exe>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' challenged systems]\n'>
                          <Id.Char_Literals '\t\t[+STDCMP?command to execute for '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals cmp>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1); prefixed by\n'>
                          <Id.Char_Literals '\t\t\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals execrate>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) on '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals .exe>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' challenged systems]\n'>
                          <Id.Char_Literals '\t\t[+STDCP?command to execute for '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals cp>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1); prefixed by\n'>
                          <Id.Char_Literals '\t\t\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals execrate>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) on '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals .exe>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' challenged systems]\n'>
                          <Id.Char_Literals '\t\t[+STDED?command to execute for '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ed>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) or '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ex>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1)]\n'>
                          <Id.Char_Literals '\t\t[+STDEDFLAGS?flags for '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals STDED>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ']\n'>
                          <Id.Char_Literals '\t\t[+STDLN?command to execute for '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ln>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1); prefixed by\n'>
                          <Id.Char_Literals '\t\t\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals execrate>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) on '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals .exe>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' challenged systems]\n'>
                          <Id.Char_Literals '\t\t[+STDMV?command to execute for '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals mv>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1); prefixed by\n'>
                          <Id.Char_Literals '\t\t\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals execrate>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) on '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals .exe>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' challenged systems]\n'>
                          <Id.Char_Literals '\t\t[+STDRM?command to execute for '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals rm>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1); prefixed by\n'>
                          <Id.Char_Literals '\t\t\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals execrate>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) on '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals .exe>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' challenged systems]\n'>
                          <Id.Char_Literals '}\n'>
                          <Id.Char_Literals '[d:debug?Enable probe script debug trace.]\n'>
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals 'info-file cc-path\n'>
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals '[+SEE ALSO?'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals execrate>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1), '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals package>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1), '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals mamake>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1), '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals nmake>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1),\n'>
                          <Id.Char_Literals '\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals probe>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1)]\n'>
                        ]
                        right: <Id.Right_SingleQuote '\''>
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Simple
                      blame_tok: <getopts>
                      more_env: []
                      words: [
                        {<getopts>}
                        {<-a>}
                        {(DQ ($ Id.VSub_DollarName command))}
                        {(DQ ($ Id.VSub_DollarName USAGE))}
                        {<OPT>}
                      ]
                      redirects: []
                      do_fork: T
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  left: <Id.KW_Do do>
                  children: [
                    (command.Case
                      case_kw: <Id.KW_Case case>
                      to_match: (case_arg.Word w:{($ Id.VSub_DollarName OPT)})
                      arms_start: <Id.KW_In in>
                      arms: [
                        (CaseArm
                          left: <d>
                          pattern: (pat.Words words:[{<d>}])
                          middle: <Id.Right_CasePat _>
                          action: [
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'opt='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'opt='>
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'opt='> name:opt)
                                  op: assign_op.Equal
                                  rhs: {<-d>}
                                )
                              ]
                              redirects: []
                            )
                          ]
                          right: <Id.Op_DSemi _>
                        )
                      ]
                      arms_end: <Id.KW_Esac esac>
                      redirects: []
                    )
                  ]
                  right: <Id.KW_Done done>
                )
              redirects: []
            )
            (command.Simple
              blame_tok: <shift>
              more_env: []
              words: [
                {<shift>}
                {
                  (CommandSub
                    left_token: <Id.Left_Backtick '`'>
                    child: 
                      (command.Simple
                        blame_tok: <expr>
                        more_env: []
                        words: [{<expr>} {($ Id.VSub_DollarName OPTIND)} {<->} {<1>}]
                        redirects: []
                        do_fork: T
                      )
                    right: <Id.Backtick_Right '`'>
                  )
                }
              ]
              redirects: []
              do_fork: T
            )
          ]
          right: <Id.Op_DSemi _>
        )
        (CaseArm
          left: <Id.Lit_Star '*'>
          pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
          middle: <Id.Right_CasePat _>
          action: [
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Simple
                      blame_tok: <Id.Lit_Colon ':'>
                      more_env: []
                      words: [{<Id.Lit_Colon ':'>}]
                      redirects: []
                      do_fork: T
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  left: <Id.KW_Do do>
                  children: [
                    (command.Case
                      case_kw: <Id.KW_Case case>
                      to_match: (case_arg.Word w:{($ Id.VSub_Pound '#')})
                      arms_start: <Id.KW_In in>
                      arms: [
                        (CaseArm
                          left: <0>
                          pattern: (pat.Words words:[{<0>}])
                          middle: <Id.Right_CasePat _>
                          action: [(command.ControlFlow keyword:<Id.ControlFlow_Break break>)]
                          right: <Id.Op_DSemi _>
                        )
                      ]
                      arms_end: <Id.KW_Esac esac>
                      redirects: []
                    )
                    (command.Case
                      case_kw: <Id.KW_Case case>
                      to_match: (case_arg.Word w:{($ Id.VSub_Number 1)})
                      arms_start: <Id.KW_In in>
                      arms: [
                        (CaseArm
                          left: <-->
                          pattern: (pat.Words words:[{<-->}])
                          middle: <Id.Right_CasePat _>
                          action: [
                            (command.Simple
                              blame_tok: <shift>
                              more_env: []
                              words: [{<shift>}]
                              redirects: []
                              do_fork: T
                            )
                            (command.ControlFlow
                              keyword: <Id.ControlFlow_Break break>
                            )
                          ]
                          right: <Id.Op_DSemi _>
                        )
                        (CaseArm
                          left: <->
                          pattern: (pat.Words words:[{<->}])
                          middle: <Id.Right_CasePat _>
                          action: [(command.ControlFlow keyword:<Id.ControlFlow_Break break>)]
                          right: <Id.Op_DSemi _>
                        )
                        (CaseArm
                          left: <-d>
                          pattern: (pat.Words words:[{<-d>}])
                          middle: <Id.Right_CasePat _>
                          action: [
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'opt='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'opt='>
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'opt='> name:opt)
                                  op: assign_op.Equal
                                  rhs: {<-d>}
                                )
                              ]
                              redirects: []
                            )
                          ]
                          right: <Id.Op_DSemi _>
                        )
                        (CaseArm
                          left: <->
                          pattern: (pat.Words words:[{<-> <Id.Lit_Star '*'>}])
                          middle: <Id.Right_CasePat _>
                          action: [
                            (command.Simple
                              blame_tok: <echo>
                              more_env: []
                              words: [
                                {<echo>}
                                {($ Id.VSub_DollarName command) <Id.Lit_Colon ':'>}
                                {($ Id.VSub_Number 1) <Id.Lit_Colon ':'>}
                                {<unknown>}
                                {<option>}
                              ]
                              redirects: [
                                (Redir
                                  op: <Id.Redir_GreatAnd '>&'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {<2>}
                                )
                              ]
                              do_fork: T
                            )
                          ]
                          right: <Id.Op_DSemi _>
                        )
                        (CaseArm
                          left: <Id.Lit_Star '*'>
                          pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                          middle: <Id.Right_CasePat _>
                          action: [(command.ControlFlow keyword:<Id.ControlFlow_Break break>)]
                          right: <Id.Op_DSemi _>
                        )
                      ]
                      arms_end: <Id.KW_Esac esac>
                      redirects: []
                    )
                    (command.Simple
                      blame_tok: <set>
                      more_env: []
                      words: [{<set>} {(SQ )}]
                      redirects: []
                      do_fork: T
                    )
                    (command.ControlFlow keyword:<Id.ControlFlow_Break break>)
                  ]
                  right: <Id.KW_Done done>
                )
              redirects: []
            )
          ]
          right: <Id.Op_DSemi _>
        )
      ]
      arms_end: <Id.KW_Esac esac>
      redirects: []
    )
    (command.Case
      case_kw: <Id.KW_Case case>
      to_match: (case_arg.Word w:{($ Id.VSub_Number 1)})
      arms_start: <Id.KW_In in>
      arms: [
        (CaseArm
          left: <->
          pattern: (pat.Words words:[{<->}])
          middle: <Id.Right_CasePat _>
          action: []
          right: <Id.Op_DSemi _>
        )
        (CaseArm
          left: <'/'>
          pattern: (pat.Words words:[{<'/'> <Id.Lit_Star '*'>}])
          middle: <Id.Right_CasePat _>
          action: []
          right: <Id.Op_DSemi _>
        )
        (CaseArm
          left: <Id.Lit_Star '*'>
          pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
          middle: <Id.Right_CasePat _>
          action: [
            (command.Simple
              blame_tok: <set>
              more_env: []
              words: [{<set>} {(SQ )}]
              redirects: []
              do_fork: T
            )
          ]
          right: <Id.Op_DSemi _>
        )
      ]
      arms_end: <Id.KW_Esac esac>
      redirects: []
    )
    (command.Case
      case_kw: <Id.KW_Case case>
      to_match: (case_arg.Word w:{($ Id.VSub_Number 2)})
      arms_start: <Id.KW_In in>
      arms: [
        (CaseArm
          left: <'/'>
          pattern: (pat.Words words:[{<'/'> <Id.Lit_Star '*'>}])
          middle: <Id.Right_CasePat _>
          action: []
          right: <Id.Op_DSemi _>
        )
        (CaseArm
          left: <Id.Lit_Star '*'>
          pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
          middle: <Id.Right_CasePat _>
          action: [
            (command.Simple
              blame_tok: <set>
              more_env: []
              words: [{<set>} {(SQ )}]
              redirects: []
              do_fork: T
            )
          ]
          right: <Id.Op_DSemi _>
        )
      ]
      arms_end: <Id.KW_Esac esac>
      redirects: []
    )
    (command.Case
      case_kw: <Id.KW_Case case>
      to_match: (case_arg.Word w:{($ Id.VSub_Pound '#')})
      arms_start: <Id.KW_In in>
      arms: [
        (CaseArm
          left: <0>
          pattern: (pat.Words words:[{<0>} {<1>}])
          middle: <Id.Right_CasePat _>
          action: [
            (command.Sentence
              child: 
                (command.Simple
                  blame_tok: <echo>
                  more_env: []
                  words: [
                    {<echo>}
                    {(DQ <'Usage: '> ($ Id.VSub_DollarName command) <' info-file cc-path'>)}
                  ]
                  redirects: [(Redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                  do_fork: T
                )
              terminator: <Id.Op_Semi _>
            )
            (command.ControlFlow keyword:<Id.ControlFlow_Exit exit> arg_word:{<2>})
          ]
          right: <Id.Op_DSemi _>
        )
      ]
      arms_end: <Id.KW_Esac esac>
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'info='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'info='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'info='> name:info)
          op: assign_op.Equal
          rhs: {($ Id.VSub_Number 1)}
        )
      ]
      redirects: []
    )
    (command.Simple blame_tok:<shift> more_env:[] words:[{<shift>}] redirects:[] do_fork:T)
    (command.ShAssignment
      left: <Id.Lit_VarLike 'cc='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'cc='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'cc='> name:cc)
          op: assign_op.Equal
          rhs: {($ Id.VSub_Star '*')}
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'ifs='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'ifs='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'ifs='> name:ifs)
          op: assign_op.Equal
          rhs: 
            {
              (BracedVarSub
                left: <Id.Left_DollarBrace '${'>
                token: <Id.VSub_Name IFS>
                var_name: IFS
                suffix_op: (suffix_op.Unary op:<Id.VTest_Hyphen _> arg_word:{(SQ <'\n'> <'\t '>)})
                right: <Id.Right_DollarBrace '}'>
              )
            }
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'IFS='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'IFS='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'IFS='> name:IFS)
          op: assign_op.Equal
          rhs: {<Id.Lit_Colon ':'>}
        )
      ]
      redirects: []
    )
    (command.Simple
      blame_tok: <set>
      more_env: []
      words: [{<set>} {($ Id.VSub_DollarName PATH)}]
      redirects: []
      do_fork: T
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'IFS='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'IFS='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'IFS='> name:IFS)
          op: assign_op.Equal
          rhs: {($ Id.VSub_DollarName ifs)}
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'script='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'script='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'script='> name:script)
          op: assign_op.Equal
          rhs: {<'lib/probe/C/make/probe'>}
        )
      ]
      redirects: []
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: 
        (condition.Shell
          commands: [
            (command.Simple
              blame_tok: <Id.Lit_Colon ':'>
              more_env: []
              words: [{<Id.Lit_Colon ':'>}]
              redirects: []
              do_fork: T
            )
          ]
        )
      body: 
        (command.DoGroup
          left: <Id.KW_Do do>
          children: [
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_Pound '#')})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <0>
                  pattern: (pat.Words words:[{<0>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.Simple
                      blame_tok: <echo>
                      more_env: []
                      words: [
                        {<echo>}
                        {
                          (DQ ($ Id.VSub_Number 0) <': ../'> ($ Id.VSub_DollarName script) 
                            <': probe script not found on PATH'>
                          )
                        }
                      ]
                      redirects: [(Redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                      do_fork: T
                    )
                    (command.ControlFlow
                      keyword: <Id.ControlFlow_Exit exit>
                      arg_word: {<1>}
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_Number 1)})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <Id.Left_SingleQuote '\''>
                  pattern: (pat.Words words:[{(SQ )}])
                  middle: <Id.Right_CasePat _>
                  action: [(command.ControlFlow keyword:<Id.ControlFlow_Continue continue>)]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'makeprobe='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'makeprobe='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'makeprobe='> name:makeprobe)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (CommandSub
                        left_token: <Id.Left_Backtick '`'>
                        child: 
                          (command.Pipeline
                            children: [
                              (command.Simple
                                blame_tok: <echo>
                                more_env: []
                                words: [{<echo>} {($ Id.VSub_Number 1)}]
                                redirects: []
                                do_fork: T
                              )
                              (command.Simple
                                blame_tok: <sed>
                                more_env: []
                                words: [
                                  {<sed>}
                                  {(SQ <'s,[^/]*$,'>) ($ Id.VSub_DollarName script) <Id.Lit_Comma ','>}
                                ]
                                redirects: []
                                do_fork: T
                              )
                            ]
                            ops: [<Id.Op_Pipe _>]
                          )
                        right: <Id.Backtick_Right '`'>
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.If
              if_kw: <Id.KW_If if>
              arms: [
                (IfArm
                  keyword: <Id.KW_If if>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Simple
                          blame_tok: <test>
                          more_env: []
                          words: [{<test>} {<-x>} {($ Id.VSub_DollarName makeprobe)}]
                          redirects: []
                          do_fork: T
                        )
                      ]
                    )
                  then_kw: <Id.KW_Then then>
                  action: [(command.ControlFlow keyword:<Id.ControlFlow_Break break>)]
                  spids: [798 807]
                )
              ]
              else_action: []
              fi_kw: <Id.KW_Fi fi>
              redirects: []
            )
            (command.Simple
              blame_tok: <shift>
              more_env: []
              words: [{<shift>}]
              redirects: []
              do_fork: T
            )
          ]
          right: <Id.KW_Done done>
        )
      redirects: []
    )
    (command.Case
      case_kw: <Id.KW_Case case>
      to_match: (case_arg.Word w:{($ Id.VSub_DollarName info)})
      arms_start: <Id.KW_In in>
      arms: [
        (CaseArm
          left: <'/'>
          pattern: (pat.Words words:[{<'/'> <Id.Lit_Star '*'>}])
          middle: <Id.Right_CasePat _>
          action: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'i='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'i='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'i='> name:i)
                  op: assign_op.Equal
                  rhs: {<X> ($ Id.VSub_DollarName info)}
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'ifs='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'ifs='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'ifs='> name:ifs)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (BracedVarSub
                        left: <Id.Left_DollarBrace '${'>
                        token: <Id.VSub_Name IFS>
                        var_name: IFS
                        suffix_op: 
                          (suffix_op.Unary
                            op: <Id.VTest_Hyphen _>
                            arg_word: {(SQ <'\n'> <'\t '>)}
                          )
                        right: <Id.Right_DollarBrace '}'>
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'IFS='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'IFS='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'IFS='> name:IFS)
                  op: assign_op.Equal
                  rhs: {<'/'>}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <set>
              more_env: []
              words: [{<set>} {($ Id.VSub_DollarName i)}]
              redirects: []
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'IFS='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'IFS='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'IFS='> name:IFS)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName ifs)}
                )
              ]
              redirects: []
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Simple
                      blame_tok: <Id.Lit_Colon ':'>
                      more_env: []
                      words: [{<Id.Lit_Colon ':'>}]
                      redirects: []
                      do_fork: T
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  left: <Id.KW_Do do>
                  children: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'i='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'i='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'i='> name:i)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_Number 1)}
                        )
                      ]
                      redirects: []
                    )
                    (command.Simple
                      blame_tok: <shift>
                      more_env: []
                      words: [{<shift>}]
                      redirects: []
                      do_fork: T
                    )
                    (command.Case
                      case_kw: <Id.KW_Case case>
                      to_match: (case_arg.Word w:{($ Id.VSub_DollarName i)})
                      arms_start: <Id.KW_In in>
                      arms: [
                        (CaseArm
                          left: <X>
                          pattern: (pat.Words words:[{<X>}])
                          middle: <Id.Right_CasePat _>
                          action: [(command.ControlFlow keyword:<Id.ControlFlow_Break break>)]
                          right: <Id.Op_DSemi _>
                        )
                      ]
                      arms_end: <Id.KW_Esac esac>
                      redirects: []
                    )
                  ]
                  right: <Id.KW_Done done>
                )
              redirects: []
            )
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_DollarName info)})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <'//'>
                  pattern: (pat.Words words:[{<'//'> <Id.Lit_Star '*'>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'path='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'path='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'path='> name:path)
                          op: assign_op.Equal
                          rhs: {<'/'>}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <Id.Lit_Star '*'>
                  pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'path='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'path='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'path='> name:path)
                          op: assign_op.Equal
                          rhs: (rhs_word__Empty)
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Simple
                      blame_tok: <Id.Lit_Colon ':'>
                      more_env: []
                      words: [{<Id.Lit_Colon ':'>}]
                      redirects: []
                      do_fork: T
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  left: <Id.KW_Do do>
                  children: [
                    (command.Case
                      case_kw: <Id.KW_Case case>
                      to_match: (case_arg.Word w:{($ Id.VSub_Pound '#')})
                      arms_start: <Id.KW_In in>
                      arms: [
                        (CaseArm
                          left: <0>
                          pattern: (pat.Words words:[{<0>} {<1>}])
                          middle: <Id.Right_CasePat _>
                          action: [(command.ControlFlow keyword:<Id.ControlFlow_Break break>)]
                          right: <Id.Op_DSemi _>
                        )
                      ]
                      arms_end: <Id.KW_Esac esac>
                      redirects: []
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'comp='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'comp='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'comp='> name:comp)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_Number 1)}
                        )
                      ]
                      redirects: []
                    )
                    (command.Simple
                      blame_tok: <shift>
                      more_env: []
                      words: [{<shift>}]
                      redirects: []
                      do_fork: T
                    )
                    (command.Case
                      case_kw: <Id.KW_Case case>
                      to_match: (case_arg.Word w:{($ Id.VSub_DollarName comp)})
                      arms_start: <Id.KW_In in>
                      arms: [
                        (CaseArm
                          left: <Id.Left_SingleQuote '\''>
                          pattern: (pat.Words words:[{(SQ )}])
                          middle: <Id.Right_CasePat _>
                          action: [(command.ControlFlow keyword:<Id.ControlFlow_Continue continue>)]
                          right: <Id.Op_DSemi _>
                        )
                      ]
                      arms_end: <Id.KW_Esac esac>
                      redirects: []
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'path='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'path='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'path='> name:path)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName path) <'/'> ($ Id.VSub_DollarName comp)}
                        )
                      ]
                      redirects: []
                    )
                    (command.If
                      if_kw: <Id.KW_If if>
                      arms: [
                        (IfArm
                          keyword: <Id.KW_If if>
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Simple
                                  blame_tok: <test>
                                  more_env: []
                                  words: [
                                    {<test>}
                                    {<Id.KW_Bang '!'>}
                                    {<-d>}
                                    {($ Id.VSub_DollarName path)}
                                  ]
                                  redirects: []
                                  do_fork: T
                                )
                              ]
                            )
                          then_kw: <Id.KW_Then then>
                          action: [
                            (command.AndOr
                              children: [
                                (command.Simple
                                  blame_tok: <mkdir>
                                  more_env: []
                                  words: [{<mkdir>} {($ Id.VSub_DollarName path)}]
                                  redirects: []
                                  do_fork: T
                                )
                                (command.ControlFlow
                                  keyword: <Id.ControlFlow_Exit exit>
                                )
                              ]
                              ops: [<Id.Op_DPipe _>]
                            )
                          ]
                          spids: [985 996]
                        )
                      ]
                      else_action: []
                      fi_kw: <Id.KW_Fi fi>
                      redirects: []
                    )
                  ]
                  right: <Id.KW_Done done>
                )
              redirects: []
            )
          ]
          right: <Id.Op_DSemi _>
        )
      ]
      arms_end: <Id.KW_Esac esac>
      redirects: []
    )
    (command.Case
      case_kw: <Id.KW_Case case>
      to_match: (case_arg.Word w:{($ Id.VSub_DollarName info)})
      arms_start: <Id.KW_In in>
      arms: [
        (CaseArm
          left: <->
          pattern: (pat.Words words:[{<->}])
          middle: <Id.Right_CasePat _>
          action: []
          right: <Id.Op_DSemi _>
        )
        (CaseArm
          left: <Id.Lit_Star '*'>
          pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
          middle: <Id.Right_CasePat _>
          action: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'tmp='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'tmp='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'tmp='> name:tmp)
                  op: assign_op.Equal
                  rhs: {<'/tmp/mam'> ($ Id.VSub_Dollar '$')}
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <trap>
              more_env: []
              words: [
                {<trap>}
                {(DQ <'exec >/dev/null; rm -f '> ($ Id.VSub_DollarName tmp))}
                {<0>}
                {<1>}
                {<2>}
                {<3>}
                {<15>}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <exec>
              more_env: []
              words: [{<exec>}]
              redirects: [
                (Redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {($ Id.VSub_DollarName tmp)}
                )
              ]
              do_fork: T
            )
            (command.Simple
              blame_tok: <echo>
              more_env: []
              words: [
                {<echo>}
                {
                  (DQ <'probing C language processor '> ($ Id.VSub_DollarName cc) 
                    <' for mam information'>
                  )
                }
              ]
              redirects: [(Redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
              do_fork: T
            )
          ]
          right: <Id.Op_DSemi _>
        )
      ]
      arms_end: <Id.KW_Esac esac>
      redirects: []
    )
    (command.Simple
      blame_tok: <echo>
      more_env: []
      words: [
        {<echo>}
        {(DQ <'note generated by '> ($ Id.VSub_Number 0) <' for '> ($ Id.VSub_DollarName cc))}
      ]
      redirects: []
      do_fork: T
    )
    (command.Pipeline
      children: [
        (command.Subshell
          left: <Id.Op_LParen _>
          child: 
            (command.CommandList
              children: [
                (command.Simple
                  blame_tok: <set>
                  more_env: []
                  words: [{<set>} {(SQ )} {($ Id.VSub_DollarName opt)} {($ Id.VSub_DollarName cc)}]
                  redirects: []
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <shift>
                  more_env: []
                  words: [{<shift>}]
                  redirects: []
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <.>
                  more_env: []
                  words: [{<.>} {($ Id.VSub_DollarName makeprobe)} {(DQ ($ Id.VSub_At '@'))}]
                  redirects: []
                  do_fork: T
                )
                (command.Case
                  case_kw: <Id.KW_Case case>
                  to_match: (case_arg.Word w:{(DQ <' '> ($ Id.VSub_DollarName CC_DIALECT) <' '>)})
                  arms_start: <Id.KW_In in>
                  arms: [
                    (CaseArm
                      left: <Id.Lit_Star '*'>
                      pattern: 
                        (pat.Words
                          words: [{<Id.Lit_Star '*'> (DQ <' -L '>) <Id.Lit_Star '*'>}]
                        )
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <echo>
                          more_env: []
                          words: [{<echo>} {(DQ <'CC.L = 1'>)}]
                          redirects: []
                          do_fork: T
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                  ]
                  arms_end: <Id.KW_Esac esac>
                  redirects: []
                )
              ]
            )
          right: <Id.Right_Subshell _>
          redirects: []
        )
        (command.Simple
          blame_tok: <sed>
          more_env: []
          words: [
            {<sed>}
            {<-e>}
            {(SQ <'/^CC\\./!d'>)}
            {<-e>}
            {(SQ <'s/^CC./setv mam_cc_/'>)}
            {<-e>}
            {(SQ <'s/^\\([^=.]*\\)\\./\\1_/'>)}
            {<-e>}
            {(SQ <'s/^\\([^=.]*\\)\\./\\1_/'>)}
            {<-e>}
            {(SQ <'s/ =//'>)}
            {<-e>}
            {(SQ <'s/\\$("\\([^"]*\\)")/\\1/g'>)}
            {<-e>}
            {(SQ <'s/\\$(\\([^)]*\\))/${\\1}/g'>)}
            {<-e>}
            {(SQ <'s/\\${CC\\./${mam_cc_}/g'>)}
          ]
          redirects: []
          do_fork: T
        )
      ]
      ops: [<Id.Op_Pipe _>]
    )
    (command.Simple
      blame_tok: <echo>
      more_env: []
      words: [{<echo>} {(SQ <'setv _hosttype_ ${mam_cc_HOSTTYPE}'>)}]
      redirects: []
      do_fork: T
    )
    (command.If
      if_kw: <Id.KW_If if>
      arms: [
        (IfArm
          keyword: <Id.KW_If if>
          cond: 
            (condition.Shell
              commands: [
                (command.Subshell
                  left: <Id.Op_LParen _>
                  child: 
                    (command.Simple
                      blame_tok: <ed>
                      more_env: []
                      words: [{<ed>}]
                      redirects: [
                        (Redir
                          op: <Id.Redir_DLess '<<'>
                          loc: (redir_loc.Fd fd:0)
                          arg: 
                            (redir_param.HereDoc
                              here_begin: {<Id.KW_Bang '!'>}
                              here_end_tok: <Id.Undefined_Tok ''>
                              stdin_parts: [<'q\n'>]
                            )
                        )
                      ]
                      do_fork: T
                    )
                  right: <Id.Right_Subshell _>
                  redirects: [
                    (Redir
                      op: <Id.Redir_Less '<'>
                      loc: (redir_loc.Fd fd:0)
                      arg: {<'/dev/null'>}
                    )
                    (Redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<'/dev/null'>}
                    )
                    (Redir
                      op: <Id.Redir_GreatAnd '2>&'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<1>}
                    )
                  ]
                )
              ]
            )
          then_kw: <Id.KW_Then then>
          action: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'STDED='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'STDED='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'STDED='> name:STDED)
                  op: assign_op.Equal
                  rhs: {<ed>}
                )
              ]
              redirects: []
            )
          ]
          spids: [1231 1256]
        )
      ]
      else_kw: <Id.KW_Else else>
      else_action: [
        (command.ShAssignment
          left: <Id.Lit_VarLike 'STDED='>
          pairs: [
            (AssignPair
              left: <Id.Lit_VarLike 'STDED='>
              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'STDED='> name:STDED)
              op: assign_op.Equal
              rhs: {<ex>}
            )
          ]
          redirects: []
        )
      ]
      fi_kw: <Id.KW_Fi fi>
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'STDEDFLAGS='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'STDEDFLAGS='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'STDEDFLAGS='> name:STDEDFLAGS)
          op: assign_op.Equal
          rhs: {<->}
        )
      ]
      redirects: []
    )
    (command.Simple
      blame_tok: <set>
      more_env: []
      words: [
        {<set>}
        {<STDCAT>}
        {<cat>}
        {<STDCHMOD>}
        {<chmod>}
        {<STDCMP>}
        {<cmp>}
        {<STDCP>}
        {<cp>}
        {<STDLN>}
        {<ln>}
        {<STDMV>}
        {<mv>}
        {<STDRM>}
        {<rm>}
      ]
      redirects: []
      do_fork: T
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: 
        (condition.Shell
          commands: [
            (command.Simple
              blame_tok: <Id.Lit_Colon ':'>
              more_env: []
              words: [{<Id.Lit_Colon ':'>}]
              redirects: []
              do_fork: T
            )
          ]
        )
      body: 
        (command.DoGroup
          left: <Id.KW_Do do>
          children: [
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_Pound '#')})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <0>
                  pattern: (pat.Words words:[{<0>} {<1>}])
                  middle: <Id.Right_CasePat _>
                  action: [(command.ControlFlow keyword:<Id.ControlFlow_Break break>)]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'p='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'p='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'p='> name:p)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 2)}
                )
              ]
              redirects: []
            )
            (command.ForEach
              keyword: <Id.KW_For for>
              iter_names: [d]
              iterable: (for_iter.Words words:[{<'/bin'>} {<'/usr/bin'>} {<'/usr/sbin'>}])
              body: 
                (command.DoGroup
                  left: <Id.KW_Do do>
                  children: [
                    (command.If
                      if_kw: <Id.KW_If if>
                      arms: [
                        (IfArm
                          keyword: <Id.KW_If if>
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Simple
                                  blame_tok: <test>
                                  more_env: []
                                  words: [
                                    {<test>}
                                    {<-x>}
                                    {($ Id.VSub_DollarName d) <'/'> ($ Id.VSub_DollarName p)}
                                  ]
                                  redirects: []
                                  do_fork: T
                                )
                              ]
                            )
                          then_kw: <Id.KW_Then then>
                          action: [
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'p='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'p='>
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'p='> name:p)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName d) <'/'> ($ Id.VSub_DollarName p)}
                                )
                              ]
                              redirects: []
                            )
                            (command.ControlFlow
                              keyword: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [1346 1357]
                        )
                      ]
                      else_action: []
                      fi_kw: <Id.KW_Fi fi>
                      redirects: []
                    )
                  ]
                  right: <Id.KW_Done done>
                )
              redirects: []
            )
            (command.Simple
              blame_tok: <eval>
              more_env: []
              words: [
                {<eval>}
                {($ Id.VSub_Number 1) <Id.Lit_Equals '='> 
                  (word_part.EscapedLiteral
                    token: <Id.Lit_EscapedChar '\\$'>
                    ch: '$'
                  ) <p>
                }
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <shift>
              more_env: []
              words: [{<shift>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <shift>
              more_env: []
              words: [{<shift>}]
              redirects: []
              do_fork: T
            )
          ]
          right: <Id.KW_Done done>
        )
      redirects: []
    )
    (command.If
      if_kw: <Id.KW_If if>
      arms: [
        (IfArm
          keyword: <Id.KW_If if>
          cond: 
            (condition.Shell
              commands: [
                (command.Simple
                  blame_tok: <execrate>
                  more_env: []
                  words: [{<execrate>}]
                  redirects: []
                  do_fork: T
                )
              ]
            )
          then_kw: <Id.KW_Then then>
          action: [
            (command.ForEach
              keyword: <Id.KW_For for>
              iter_names: [n]
              iterable: 
                (for_iter.Words
                  words: [{<STDCAT>} {<STDCHMOD>} {<STDCMP>} {<STDCP>} {<STDLN>} {<STDMV>} {<STDRM>}]
                )
              body: 
                (command.DoGroup
                  left: <Id.KW_Do do>
                  children: [
                    (command.Simple
                      blame_tok: <eval>
                      more_env: []
                      words: [
                        {<eval>}
                        {($ Id.VSub_DollarName n) <Id.Lit_Equals '='> 
                          (word_part.EscapedLiteral
                            token: <Id.Lit_EscapedChar '\\"'>
                            ch: '"'
                          ) <execrate>
                        }
                        {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') 
                          ($ Id.VSub_DollarName n) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"')
                        }
                      ]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  right: <Id.KW_Done done>
                )
              redirects: []
            )
          ]
          spids: [1389 1393]
        )
      ]
      else_action: []
      fi_kw: <Id.KW_Fi fi>
      redirects: []
    )
    (command.ForEach
      keyword: <Id.KW_For for>
      iter_names: [n]
      iterable: 
        (for_iter.Words
          words: [
            {<STDCAT>}
            {<STDCHMOD>}
            {<STDCMP>}
            {<STDCP>}
            {<STDED>}
            {<STDEDFLAGS>}
            {<STDLN>}
            {<STDMV>}
            {<STDRM>}
          ]
        )
      body: 
        (command.DoGroup
          left: <Id.KW_Do do>
          children: [
            (command.Simple
              blame_tok: <eval>
              more_env: []
              words: [
                {<eval>}
                {<echo>}
                {<setv>}
                {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') <n>}
                {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') 
                  ($ Id.VSub_DollarName n)
                }
              ]
              redirects: []
              do_fork: T
            )
          ]
          right: <Id.KW_Done done>
        )
      redirects: []
    )
    (command.Case
      case_kw: <Id.KW_Case case>
      to_match: (case_arg.Word w:{($ Id.VSub_DollarName info)})
      arms_start: <Id.KW_In in>
      arms: [
        (CaseArm
          left: <->
          pattern: (pat.Words words:[{<->}])
          middle: <Id.Right_CasePat _>
          action: []
          right: <Id.Op_DSemi _>
        )
        (CaseArm
          left: <Id.Lit_Star '*'>
          pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
          middle: <Id.Right_CasePat _>
          action: [
            (command.Simple
              blame_tok: <exec>
              more_env: []
              words: [{<exec>}]
              redirects: [(Redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<'/dev/null'>})]
              do_fork: T
            )
            (command.AndOr
              children: [
                (command.Simple
                  blame_tok: <test>
                  more_env: []
                  words: [{<test>} {<-f>} {($ Id.VSub_DollarName info)}]
                  redirects: []
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <rm>
                  more_env: []
                  words: [{<rm>} {<-f>} {($ Id.VSub_DollarName info)}]
                  redirects: []
                  do_fork: T
                )
              ]
              ops: [<Id.Op_DAmp _>]
            )
            (command.Simple
              blame_tok: <cp>
              more_env: []
              words: [{<cp>} {($ Id.VSub_DollarName tmp)} {($ Id.VSub_DollarName info)}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <chmod>
              more_env: []
              words: [{<chmod>} {<-w>} {($ Id.VSub_DollarName info)}]
              redirects: []
              do_fork: T
            )
          ]
          right: <Id.Op_DSemi _>
        )
      ]
      arms_end: <Id.KW_Esac esac>
      redirects: []
    )
  ]
)