(command.CommandList
  children: [
    (command.ShFunction
      keyword: <Id.KW_Function function>
      name_tok: <logmsg>
      name: logmsg
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <print>
              more_env: []
              words: [
                {<print>}
                {<-ru2>}
                {($ Id.VSub_DollarName command) <Id.Lit_Colon ':'>}
                {(DQ ($ Id.VSub_At '@'))}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      keyword: <Id.KW_Function function>
      name_tok: <err_exit>
      name: err_exit
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <logmsg>
              more_env: []
              words: [{<logmsg>} {(DQ ($ Id.VSub_At '@'))}]
              redirects: []
              do_fork: T
            )
            (command.ControlFlow keyword:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.Simple
      blame_tok: <trap>
      more_env: []
      words: [{<trap>} {(SQ <'rm -rf /tmp/shar$$*'>)} {<EXIT>}]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <trap>
      more_env: []
      words: [{<trap>} {(SQ <'err_exit qutting early'>)} {<HUP>} {<INT>} {<QUIT>} {<TERM>}]
      redirects: []
      do_fork: T
    )
    (command.Case
      case_kw: <Id.KW_Case case>
      to_match: 
        (case_arg.Word
          w: 
            {
              (CommandSub
                left_token: <Id.Left_DollarParen '$('>
                child: 
                  (command.CommandList
                    children: [
                      (command.Sentence
                        child: 
                          (command.Simple
                            blame_tok: <getopts>
                            more_env: []
                            words: [{<getopts>} {(SQ <'[-][123:xyz]'>)} {<opt>} {<--xyz>}]
                            redirects: [
                              (Redir
                                op: <Id.Redir_Great '2>'>
                                loc: (redir_loc.Fd fd:2)
                                arg: {<'/dev/null'>}
                              )
                            ]
                            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.Eof_RParen _>
              )
            }
        )
      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: shar (AT&T Labs Research) 1999-04-20 $\n'>
                          <Id.Char_Literals ']\n'>
                        ]
                        right: <Id.Right_SingleQuote '\''>
                      ) ($ Id.VSub_DollarName USAGE_LICENSE) 
                      (SingleQuoted
                        left: <Id.Left_DollarSingleQuote '$\''>
                        tokens: [
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals '\t[+NAME? shar - create a shell archive]\n'>
                          <Id.Char_Literals '\t[+DESCRIPTION?'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals shar>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' reads one or more input files and creates a\n'>
                          <Id.Char_Literals 
'\t\tshell script which when executed will restore the contents\n'
                          >
                          <Id.Char_Literals '\t\tof these files. This is called a shell archive or '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals shar>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals '.\n'>
                          <Id.Char_Literals 
'\t\tThe resulting archive is sent to standard output unless the\n'
                          >
                          <Id.Char_Literals '\t\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -o>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' option is specified.]\n'>
                          <Id.Char_Literals '\t[a:net-headers?Automatic generation of headers. The '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -n>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' option\n'>
                          <Id.Char_Literals 
'\t\tmust also be specified. If the archive name does not\n'
                          >
                          <Id.Char_Literals '\t\tcontain a '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '/'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ', then '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '/part'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' will be append to the\n'>
                          <Id.Char_Literals 
'\t\tgiven archive name when constructing the header.]\n'
                          >
                          <Id.Char_Literals '\t[b:bits-per-code]:[bits?When doing compression, use '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '-b '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals bits>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals '\t\tas a parameter to '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals compress>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1). The '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -b>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' option turns on\n'>
                          <Id.Char_Literals '\t\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -Z>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '.]\n'>
                          <Id.Char_Literals '\t[c:cut-mark?Start the shar with a cut line.]\n'>
                          <Id.Char_Literals '\t[d:here-delimiter]:[string?Use '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals string>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ' to delimit the files \n'>
                          <Id.Char_Literals '\t\tin the shar instead of '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals SHAR_EOF>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '.]\n'>
                          <Id.Char_Literals '\t[f:basenames?Use the basenames for the files.]\n'>
                          <Id.Char_Literals 
'\t[g:level-for-gzip]:[level?When doing compression, use '
                          >
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ->
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals level>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals '\t\tas a parameter to '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals gzip>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1). The '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -g>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' option turns on\n'>
                          <Id.Char_Literals '\t\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -z>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '.]\n'>
                          <Id.Char_Literals 
'\t[l:whole-size-limit]#[size?Limit the output file size to '
                          >
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals size>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals '\t\tbytes. A suffix of '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals b>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ', '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals k>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ', or '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals m>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' can be specified\n'>
                          <Id.Char_Literals 
'\t\tto indicate 512-byte blocks, kilobytes, or megabytes\n'
                          >
                          <Id.Char_Literals '\t\trespectively.]\n'>
                          <Id.Char_Literals 
'\t[n:archive-name:name]:[name?Override automatically determined name\n'
                          >
                          <Id.Char_Literals '\t\tfor the archive with '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals name>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals '.]\n'>
                          <Id.Char_Literals '\t[o:output-prefix]:[prefix?Save the archive files '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals prefix>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals .01>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals '\t\tthrough '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals prefix>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals .>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals nn>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ' instead of standard output. This\n'>
                          <Id.Char_Literals '\t\toption must be used when '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -l>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' or the '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -L>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' is specified.]\n'>
                          <Id.Char_Literals 
'\t[p:intermix-type?Allow positional parameter options. The options\n'
                          >
                          <Id.Char_Literals '\t\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -B>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ', '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -T>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ', '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -z>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' and '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -Z>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' may be embedded, and files\n'>
                          <Id.Char_Literals 
'\t\tto the right of the option will be processed in the specified\n'
                          >
                          <Id.Char_Literals '\t\tmode.]\n'>
                          <Id.Char_Literals 
'\t[q:quit|silent?Do not output verbose messages locally when producing\n'
                          >
                          <Id.Char_Literals '\t\tthe archive.]\n'>
                          <Id.Char_Literals 
'\t[s:submitter]:[user?Override automatically determined submitter name\n'
                          >
                          <Id.Char_Literals '\t\twith '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals user>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ' which is of the form '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals who>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '@'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals where>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals '.]\n'>
                          <Id.Char_Literals '\t[t:tty?Write errors and the name of each file to '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '/dev/tty'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' as it is\n'>
                          <Id.Char_Literals '\t\tarchived.]\n'>
                          <Id.Char_Literals '\t[w:no-character-count?Do NOT check each file with '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals 'wc -c'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' after\n'>
                          <Id.Char_Literals '\t\tunpack.]\n'>
                          <Id.Char_Literals '\t[z:gzip?'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals gzip>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) and '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals uuencode>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) all files prior to packing.]\n'>
                          <Id.Char_Literals 
'\t[B:uuencode,binary-files-files?Treat all files as binary and\n'
                          >
                          <Id.Char_Literals '\t\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals uuencode>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) prior to packing.]\n'>
                          <Id.Char_Literals '\t[D:no-md5-digest?Do NOT use '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals 'cksum md5sum'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' digest to verify \n'>
                          <Id.Char_Literals '\t\tthe unpacked files. The default is to check.]\n'>
                          <Id.Char_Literals 
'\t[L:split-size-limit]#[size?Limit the output file size to '
                          >
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals size>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals '\t\tbytes as with '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -l>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ', but split the archive into multiple \n'>
                          <Id.Char_Literals '\t\tfiles.]\n'>
                          <Id.Char_Literals 
'\t[Q:quiet-unshar?Verbose OFF. Disables the inclusion of comments to\n'
                          >
                          <Id.Char_Literals '\t\tbe output when the archive is unpacked.]\n'>
                          <Id.Char_Literals 
'\t[M:mixed-uuencode?Mixed mode. Determine if the files are text or\n'
                          >
                          <Id.Char_Literals 
'\t\tbinary and archive correctly. Files found to be binary \n'
                          >
                          <Id.Char_Literals 
'\t\tare uuencoded prior to packing. This is the default.]\n'
                          >
                          <Id.Char_Literals 
'\t[S:stdin-file-list?Read list of files to be packed from the standard\n'
                          >
                          <Id.Char_Literals 
'\t\tinput rather than from the command line in the format\n'
                          >
                          <Id.Char_Literals '\t\tgenerated by '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals find>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) and '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals tw>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1). If '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -p>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' is specified,\n'>
                          <Id.Char_Literals '\t\tthe options '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -B>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ', '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -T>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ', '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -z>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' and '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -Z>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' must be\n'>
                          <Id.Char_Literals '\t\tincluded in the standard input.]\n'>
                          <Id.Char_Literals '\t[T:text-files?Treat all files as text.]\n'>
                          <Id.Char_Literals 
'\t[X:query-user?When unpacking, ask the user if files should be \n'
                          >
                          <Id.Char_Literals '\t\toverwritten.]\n'>
                          <Id.Char_Literals '\t[Z:compress?'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals compress>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) and '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals uuencode>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) all files prior to\n'>
                          <Id.Char_Literals '\t\tpacking.]\n'>
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals '\t[files ...]\n'>
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals '\t[+SEE ALSO?'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals cksum>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1), '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals compress>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1), '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals find>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1), '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals gzip>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1),\n'>
                          <Id.Char_Literals '\t\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals pax>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1), '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals tw>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1), '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals uuencode>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1), '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals wc>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1)]\n'>
                          <Id.Char_Literals '    '>
                        ]
                        right: <Id.Right_SingleQuote '\''>
                      )
                    }
                )
              ]
              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 '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: 
                    {
                      (SQ 
                        <
'ab:[bits]cd:[delim]fg:[level]l#[size]n:[name]o:[prefix]pqs:[who]tzBDL#[size]MQSXTZ files ...'
                        >
                      )
                    }
                )
              ]
              redirects: []
            )
          ]
          right: <Id.Op_DSemi _>
        )
      ]
      arms_end: <Id.KW_Esac esac>
      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: 
            {
              (SingleQuoted
                left: <Id.Left_DollarSingleQuote '$\''>
                tokens: [<Id.Char_OneChar '\\n'>]
                right: <Id.Right_SingleQuote '\''>
              )
            }
        )
      ]
      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: 
            {
              (BracedVarSub
                left: <Id.Left_DollarBrace '${'>
                token: <Id.VSub_Number 0>
                var_name: 0
                suffix_op: 
                  (suffix_op.Unary
                    op: <Id.VOp1_DPound '##'>
                    arg_word: {<Id.Lit_Other '*'> <Id.Lit_Slash '/'>}
                  )
                right: <Id.Right_DollarBrace '}'>
              )
            }
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'user='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'user='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'user='> name:user)
          op: assign_op.Equal
          rhs: 
            {
              (BracedVarSub
                left: <Id.Left_DollarBrace '${'>
                token: <Id.VSub_Name USER>
                var_name: USER
                suffix_op: 
                  (suffix_op.Unary
                    op: <Id.VTest_ColonHyphen _>
                    arg_word: 
                      {
                        (BracedVarSub
                          left: <Id.Left_DollarBrace '${'>
                          token: <Id.VSub_Name LOGNAME>
                          var_name: LOGNAME
                          suffix_op: 
                            (suffix_op.Unary
                              op: <Id.VTest_ColonHyphen _>
                              arg_word: 
                                {
                                  (CommandSub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (command.AndOr
                                        children: [
                                          (command.Simple
                                            blame_tok: <whoami>
                                            more_env: []
                                            words: [{<whoami>}]
                                            redirects: [
                                              (Redir
                                                op: <Id.Redir_Great '2>'>
                                                loc: (redir_loc.Fd fd:2)
                                                arg: {<'/dev/null'>}
                                              )
                                            ]
                                            do_fork: T
                                          )
                                          (command.Pipeline
                                            children: [
                                              (command.Simple
                                                blame_tok: <who>
                                                more_env: []
                                                words: [{<who>} {<am>} {<i>}]
                                                redirects: []
                                                do_fork: T
                                              )
                                              (command.Simple
                                                blame_tok: <sed>
                                                more_env: []
                                                words: [
                                                  {<sed>}
                                                  {
                                                    (SingleQuoted
                                                      left: <Id.Left_DollarSingleQuote '$\''>
                                                      tokens: [
                                                        <Id.Char_Literals 's/[ '>
                                                        <Id.Char_OneChar '\\t'>
                                                        <Id.Char_Literals '].*//'>
                                                      ]
                                                      right: <Id.Right_SingleQuote '\''>
                                                    )
                                                  }
                                                ]
                                                redirects: []
                                                do_fork: T
                                              )
                                            ]
                                            ops: [<Id.Op_Pipe _>]
                                          )
                                        ]
                                        ops: [<Id.Op_DPipe _>]
                                      )
                                    right: <Id.Eof_RParen _>
                                  )
                                }
                            )
                          right: <Id.Right_DollarBrace '}'>
                        )
                      }
                  )
                right: <Id.Right_DollarBrace '}'>
              ) <Id.Lit_At '@'> 
              (CommandSub
                left_token: <Id.Left_DollarParen '$('>
                child: 
                  (command.Simple
                    blame_tok: <hostname>
                    more_env: []
                    words: [{<hostname>}]
                    redirects: []
                    do_fork: T
                  )
                right: <Id.Eof_RParen _>
              )
            }
        )
      ]
      redirects: []
    )
    (command.Simple
      blame_tok: <integer>
      more_env: []
      words: [{<integer>} {<Id.Lit_VarLike 'size='> <0>}]
      redirects: []
      do_fork: T
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'flags='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'flags='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'flags='> name:flags)
          op: assign_op.Equal
          rhs: (rhs_word__Empty)
        )
        (AssignPair
          left: <Id.Lit_VarLike 'prefix='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'prefix='> name:prefix)
          op: assign_op.Equal
          rhs: (rhs_word__Empty)
        )
        (AssignPair
          left: <Id.Lit_VarLike 'mode='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'mode='> name:mode)
          op: assign_op.Equal
          rhs: {<M>}
        )
        (AssignPair
          left: <Id.Lit_VarLike 'arg='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'arg='> name:arg)
          op: assign_op.Equal
          rhs: (rhs_word__Empty)
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'separator='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'separator='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'separator='> name:separator)
          op: assign_op.Equal
          rhs: {<SHAR_EOF>}
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'skipping='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'skipping='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'skipping='> name:skipping)
          op: assign_op.Equal
          rhs: 
            {
              (DoubleQuoted
                left: <Id.Left_DollarDoubleQuote '$"'>
                parts: [<'echo \'x -\' SKIPPING'>]
                right: <Id.Right_DoubleQuote '"'>
              )
            }
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'exists='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'exists='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'exists='> name:exists)
          op: assign_op.Equal
          rhs: 
            {
              (DoubleQuoted
                left: <Id.Left_DollarDoubleQuote '$"'>
                parts: [<'\'(file already exists)\''>]
                right: <Id.Right_DoubleQuote '"'>
              )
            }
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'extract='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'extract='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'extract='> name:extract)
          op: assign_op.Equal
          rhs: 
            {
              (DoubleQuoted
                left: <Id.Left_DollarDoubleQuote '$"'>
                parts: [<'echo \'x -\' extracting'>]
                right: <Id.Right_DoubleQuote '"'>
              )
            }
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'mkdir='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'mkdir='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'mkdir='> name:mkdir)
          op: assign_op.Equal
          rhs: 
            {
              (DoubleQuoted
                left: <Id.Left_DollarDoubleQuote '$"'>
                parts: [<'creating directory'>]
                right: <Id.Right_DoubleQuote '"'>
              )
            }
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'uncomp='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'uncomp='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'uncomp='> name:uncomp)
          op: assign_op.Equal
          rhs: 
            {
              (DoubleQuoted
                left: <Id.Left_DollarDoubleQuote '$"'>
                parts: [<'uncompressing file'>]
                right: <Id.Right_DoubleQuote '"'>
              )
            }
        )
      ]
      redirects: []
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: 
        (condition.Shell
          commands: [
            (command.Simple
              blame_tok: <getopts>
              more_env: []
              words: [{<getopts>} {(DQ ($ Id.VSub_DollarName usage))} {<c>}]
              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 c)})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <Id.Lit_LBracket '['>
                  pattern: 
                    (pat.Words
                      words: [{<Id.Lit_LBracket '['> <acfpqwDSQX> <Id.Lit_RBracket ']'>}]
                    )
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'flags='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'flags='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'flags='> name:flags)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName flags) ($ Id.VSub_DollarName c)}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <b>
                  pattern: (pat.Words words:[{<b>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'mode='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'mode='>
                              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'mode='> name:mode)
                              op: assign_op.Equal
                              rhs: {<Z>}
                            )
                          ]
                          redirects: []
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'arg='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'arg='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'arg='> name:arg)
                          op: assign_op.Equal
                          rhs: {<-> (DQ <'b '> ($ Id.VSub_DollarName OPTARG))}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <g>
                  pattern: (pat.Words words:[{<g>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'mode='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'mode='>
                              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'mode='> name:mode)
                              op: assign_op.Equal
                              rhs: {<z>}
                            )
                          ]
                          redirects: []
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'arg='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'arg='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'arg='> name:arg)
                          op: assign_op.Equal
                          rhs: {<-> ($ Id.VSub_DollarName OPTARG)}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <l>
                  pattern: (pat.Words words:[{<l>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'size='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'size='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'size='> name:size)
                          op: assign_op.Equal
                          rhs: {<OPTARG>}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <L>
                  pattern: (pat.Words words:[{<L>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'split='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'split='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'split='> name:split)
                          op: assign_op.Equal
                          rhs: {<1>}
                        )
                        (AssignPair
                          left: <Id.Lit_VarLike 'size='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'size='> name:size)
                          op: assign_op.Equal
                          rhs: {<OPTARG>}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <d>
                  pattern: (pat.Words words:[{<d>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'separator='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'separator='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'separator='> name:separator)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName OPTARG)}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <n>
                  pattern: (pat.Words words:[{<n>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'aname='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'aname='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'aname='> name:aname)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName OPTARG)}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <o>
                  pattern: (pat.Words words:[{<o>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'prefix='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'prefix='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'prefix='> name:prefix)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName OPTARG)}
                        )
                      ]
                      redirects: []
                    )
                    (command.Simple
                      blame_tok: <exec>
                      more_env: []
                      words: [{<exec>}]
                      redirects: [
                        (Redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {<'/tmp/shar'> ($ Id.VSub_Dollar '$') <.1>}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <s>
                  pattern: (pat.Words words:[{<s>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'user='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'user='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'user='> name:user)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName OPTARG)}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <q>
                  pattern: (pat.Words words:[{<q>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'verbose='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'verbose='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'verbose='> name:verbose)
                          op: assign_op.Equal
                          rhs: (rhs_word__Empty)
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <t>
                  pattern: (pat.Words words:[{<t>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'verbose='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'verbose='>
                              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'verbose='> name:verbose)
                              op: assign_op.Equal
                              rhs: {<1>}
                            )
                          ]
                          redirects: []
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (command.Simple
                      blame_tok: <exec>
                      more_env: []
                      words: [{<exec>}]
                      redirects: [
                        (Redir
                          op: <Id.Redir_Great '2>'>
                          loc: (redir_loc.Fd fd:2)
                          arg: {<'/dev/tty'>}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <v>
                  pattern: (pat.Words words:[{<v>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'verbose='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'verbose='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'verbose='> name:verbose)
                          op: assign_op.Equal
                          rhs: {<1>}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <Id.Lit_LBracket '['>
                  pattern: (pat.Words words:[{<Id.Lit_LBracket '['> <zZBMT> <Id.Lit_RBracket ']'>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'mode='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'mode='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'mode='> name:mode)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName c)}
                        )
                      ]
                      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>}
        {
          (word_part.ArithSub
            left: <Id.Left_DollarDParen '$(('>
            anode: 
              (arith_expr.Binary
                op_id: Id.Arith_Minus
                left: ($ Id.Lit_ArithVarLike OPTIND)
                right: {<Id.Lit_Digits 1>}
              )
            right: <Id.Right_DollarDParen _>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.If
      if_kw: <Id.KW_If if>
      arms: [
        (IfArm
          keyword: <Id.KW_If if>
          cond: 
            (condition.Shell
              commands: [
                (command.AndOr
                  children: [
                    (command.DParen
                      left: <Id.Op_DLeftParen _>
                      child: 
                        (arith_expr.Binary
                          op_id: Id.Arith_DEqual
                          left: {($ Id.VSub_Pound '#')}
                          right: {<Id.Lit_Digits 0>}
                        )
                      right: <Id.Op_DRightParen _>
                      redirects: []
                    )
                    (command.DBracket
                      left: <Id.KW_DLeftBracket '[['>
                      expr: 
                        (bool_expr.Binary
                          op_id: Id.BoolBinary_GlobNEqual
                          left: {($ Id.VSub_DollarName flags)}
                          right: {<Id.Lit_Other '*'> <S> <Id.Lit_Other '*'>}
                        )
                      right: <Id.Lit_DRightBracket ']]'>
                      redirects: []
                    )
                  ]
                  ops: [<Id.Op_DAmp _>]
                )
              ]
            )
          then_kw: <Id.KW_Then then>
          action: [
            (command.Simple
              blame_tok: <err_exit>
              more_env: []
              words: [{<err_exit>} {(DQ <'no arguments left!'>)}]
              redirects: []
              do_fork: T
            )
          ]
          spids: [775 801]
        )
      ]
      else_action: []
      fi_kw: <Id.KW_Fi fi>
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'contents='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'contents='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'contents='> name:contents)
          op: assign_op.Equal
          rhs: {(SQ )}
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'contdirs='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'contdirs='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'contdirs='> name:contdirs)
          op: assign_op.Equal
          rhs: {(SQ )}
        )
      ]
      redirects: []
    )
    (command.ShFunction
      keyword: <Id.KW_Function function>
      name_tok: <preprocess_files>
      name: preprocess_files
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <typeset>
              more_env: []
              words: [{<typeset>} {<Id.Lit_VarLike 'file='> ($ Id.VSub_Number 1)}]
              redirects: []
              do_fork: T
            )
            (command.If
              if_kw: <Id.KW_If if>
              arms: [
                (IfArm
                  keyword: <Id.KW_If if>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.DBracket
                          left: <Id.KW_DLeftBracket '[['>
                          expr: 
                            (bool_expr.LogicalAnd
                              left: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {($ Id.VSub_DollarName flags)}
                                  right: {<Id.Lit_Other '*'> <p> <Id.Lit_Other '*'>}
                                )
                              right: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {($ Id.VSub_DollarName file)}
                                  right: {<-> <Id.Lit_Other '['> <zBTZ> <Id.Lit_Other ']'>}
                                )
                            )
                          right: <Id.Lit_DRightBracket ']]'>
                          redirects: []
                        )
                      ]
                    )
                  then_kw: <Id.KW_Then then>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'mode='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'mode='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'mode='> name:mode)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (BracedVarSub
                                left: <Id.Left_DollarBrace '${'>
                                token: <Id.VSub_Name file>
                                var_name: file
                                suffix_op: (suffix_op.Unary op:<Id.VOp1_Pound '#'> arg_word:{<->})
                                right: <Id.Right_DollarBrace '}'>
                              )
                            }
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [840 866]
                )
                (IfArm
                  keyword: <Id.KW_Elif elif>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.DBracket
                          left: <Id.KW_DLeftBracket '[['>
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_f
                              child: {($ Id.VSub_DollarName file)}
                            )
                          right: <Id.Lit_DRightBracket ']]'>
                          redirects: []
                        )
                      ]
                    )
                  then_kw: <Id.KW_Then then>
                  action: [
                    (command.If
                      if_kw: <Id.KW_If if>
                      arms: [
                        (IfArm
                          keyword: <Id.KW_If if>
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.DBracket
                                  left: <Id.KW_DLeftBracket '[['>
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobDEqual
                                      left: {($ Id.VSub_DollarName flags)}
                                      right: {<Id.Lit_Other '*'> <f> <Id.Lit_Other '*'>}
                                    )
                                  right: <Id.Lit_DRightBracket ']]'>
                                  redirects: []
                                )
                              ]
                            )
                          then_kw: <Id.KW_Then then>
                          action: [
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'contents='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'contents='>
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'contents='>
                                      name: contents
                                    )
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ ($ Id.VSub_DollarName contents) ($ Id.VSub_DollarName IFS) 
                                        (BracedVarSub
                                          left: <Id.Left_DollarBrace '${'>
                                          token: <Id.VSub_Name file>
                                          var_name: file
                                          suffix_op: 
                                            (suffix_op.Unary
                                              op: <Id.VOp1_DPound '##'>
                                              arg_word: {<Id.Lit_Other '*'> <Id.Lit_Slash '/'>}
                                            )
                                          right: <Id.Right_DollarBrace '}'>
                                        )
                                      )
                                    }
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [889 904]
                        )
                      ]
                      else_kw: <Id.KW_Else else>
                      else_action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'contents='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'contents='>
                              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'contents='> name:contents)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ ($ Id.VSub_DollarName contents) ($ Id.VSub_DollarName IFS) 
                                    ($ Id.VSub_DollarName file)
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                      ]
                      fi_kw: <Id.KW_Fi fi>
                      redirects: []
                    )
                  ]
                  spids: [876 887]
                )
                (IfArm
                  keyword: <Id.KW_Elif elif>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.DBracket
                          left: <Id.KW_DLeftBracket '[['>
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_d
                              child: {($ Id.VSub_DollarName file)}
                            )
                          right: <Id.Lit_DRightBracket ']]'>
                          redirects: []
                        )
                      ]
                    )
                  then_kw: <Id.KW_Then then>
                  action: [
                    (command.If
                      if_kw: <Id.KW_If if>
                      arms: [
                        (IfArm
                          keyword: <Id.KW_If if>
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.DBracket
                                  left: <Id.KW_DLeftBracket '[['>
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobDEqual
                                      left: {($ Id.VSub_DollarName flags)}
                                      right: {<Id.Lit_Other '*'> <f> <Id.Lit_Other '*'>}
                                    )
                                  right: <Id.Lit_DRightBracket ']]'>
                                  redirects: []
                                )
                              ]
                            )
                          then_kw: <Id.KW_Then then>
                          action: [
                            (command.Simple
                              blame_tok: <err_exit>
                              more_env: []
                              words: [
                                {<err_exit>}
                                {
                                  (DQ <'cannot archive directory '> ($ Id.VSub_DollarName file) 
                                    <' with -b option.'>
                                  )
                                }
                              ]
                              redirects: []
                              do_fork: T
                            )
                          ]
                          spids: [945 960]
                        )
                      ]
                      else_action: []
                      fi_kw: <Id.KW_Fi fi>
                      redirects: []
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'contdirs='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'contdirs='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'contdirs='> name:contdirs)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ ($ Id.VSub_DollarName contdirs) ($ Id.VSub_DollarName IFS) 
                                ($ Id.VSub_DollarName file) <'/ '>
                              )
                            }
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [932 943]
                )
              ]
              else_kw: <Id.KW_Else else>
              else_action: [
                (command.Simple
                  blame_tok: <err_exit>
                  more_env: []
                  words: [{<err_exit>} {(DQ <'cannot archive '> ($ Id.VSub_DollarName file))}]
                  redirects: []
                  do_fork: T
                )
              ]
              fi_kw: <Id.KW_Fi fi>
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.If
      if_kw: <Id.KW_If if>
      arms: [
        (IfArm
          keyword: <Id.KW_If if>
          cond: 
            (condition.Shell
              commands: [
                (command.DBracket
                  left: <Id.KW_DLeftBracket '[['>
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_GlobDEqual
                      left: {($ Id.VSub_DollarName flags)}
                      right: {<Id.Lit_Other '*'> <S> <Id.Lit_Other '*'>}
                    )
                  right: <Id.Lit_DRightBracket ']]'>
                  redirects: []
                )
              ]
            )
          then_kw: <Id.KW_Then then>
          action: [
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Simple
                      blame_tok: <read>
                      more_env: []
                      words: [{<read>} {<-r>} {<file>}]
                      redirects: []
                      do_fork: T
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  left: <Id.KW_Do do>
                  children: [
                    (command.Simple
                      blame_tok: <preprocess_files>
                      more_env: []
                      words: [{<preprocess_files>} {(DQ ($ Id.VSub_DollarName file))}]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <print>
                      more_env: []
                      words: [{<print>} {<-r>} {<-->} {(DQ ($ Id.VSub_DollarName file))}]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  right: <Id.KW_Done done>
                )
              redirects: [
                (Redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {<'/tmp/shar'> ($ Id.VSub_Dollar '$') <.3>}
                )
              ]
            )
          ]
          spids: [999 1013]
        )
      ]
      else_kw: <Id.KW_Else else>
      else_action: [
        (command.ForEach
          keyword: <Id.KW_For for>
          iter_names: [file]
          iterable: (for_iter__Args)
          body: 
            (command.DoGroup
              left: <Id.KW_Do do>
              children: [
                (command.Simple
                  blame_tok: <preprocess_files>
                  more_env: []
                  words: [{<preprocess_files>} {(DQ ($ Id.VSub_DollarName file))}]
                  redirects: []
                  do_fork: T
                )
              ]
              right: <Id.KW_Done done>
            )
          redirects: []
        )
      ]
      fi_kw: <Id.KW_Fi fi>
      redirects: []
    )
    (command.If
      if_kw: <Id.KW_If if>
      arms: [
        (IfArm
          keyword: <Id.KW_If if>
          cond: 
            (condition.Shell
              commands: [
                (command.DBracket
                  left: <Id.KW_DLeftBracket '[['>
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_GlobDEqual
                      left: {($ Id.VSub_DollarName flags)}
                      right: {<Id.Lit_Other '*'> <a> <Id.Lit_Other '*'>}
                    )
                  right: <Id.Lit_DRightBracket ']]'>
                  redirects: []
                )
              ]
            )
          then_kw: <Id.KW_Then then>
          action: [
            (command.If
              if_kw: <Id.KW_If if>
              arms: [
                (IfArm
                  keyword: <Id.KW_If if>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.DBracket
                          left: <Id.KW_DLeftBracket '[['>
                          expr: (bool_expr.WordTest w:{($ Id.VSub_DollarName aname)})
                          right: <Id.Lit_DRightBracket ']]'>
                          redirects: []
                        )
                      ]
                    )
                  then_kw: <Id.KW_Then then>
                  action: [
                    (command.If
                      if_kw: <Id.KW_If if>
                      arms: [
                        (IfArm
                          keyword: <Id.KW_If if>
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.DBracket
                                  left: <Id.KW_DLeftBracket '[['>
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobNEqual
                                      left: {($ Id.VSub_DollarName aname)}
                                      right: {<Id.Lit_Other '*'> <'/'> <Id.Lit_Other '*'>}
                                    )
                                  right: <Id.Lit_DRightBracket ']]'>
                                  redirects: []
                                )
                              ]
                            )
                          then_kw: <Id.KW_Then then>
                          action: [
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'aname='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'aname='>
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'aname='> name:aname)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName aname) <'/part'>}
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [1101 1116]
                        )
                      ]
                      else_action: []
                      fi_kw: <Id.KW_Fi fi>
                      redirects: []
                    )
                    (command.Simple
                      blame_tok: <cat>
                      more_env: []
                      words: [{<cat>}]
                      redirects: [
                        (Redir
                          op: <Id.Redir_DLessDash '<<-'>
                          loc: (redir_loc.Fd fd:0)
                          arg: 
                            (redir_param.HereDoc
                              here_begin: {<Id.KW_Bang '!'> <Id.KW_Bang '!'> <Id.KW_Bang '!'>}
                              here_end_tok: <Id.Undefined_Tok ''>
                              stdin_parts: [
                                <'Submitted-by:  '>
                                ($ Id.VSub_DollarName user)
                                <'\n'>
                                <'Archive-name: '>
                                (${ Id.VSub_Name aname)
                                <'01\n'>
                                <'\n'>
                              ]
                            )
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  spids: [1090 1099]
                )
              ]
              else_kw: <Id.KW_Else else>
              else_action: [
                (command.Simple
                  blame_tok: <err_exit>
                  more_env: []
                  words: [{<err_exit>} {(DQ <'Cannot use -a without -n'>)}]
                  redirects: []
                  do_fork: T
                )
              ]
              fi_kw: <Id.KW_Fi fi>
              redirects: []
            )
          ]
          spids: [1074 1088]
        )
      ]
      else_action: []
      fi_kw: <Id.KW_Fi fi>
      redirects: []
    )
    (command.If
      if_kw: <Id.KW_If if>
      arms: [
        (IfArm
          keyword: <Id.KW_If if>
          cond: 
            (condition.Shell
              commands: [
                (command.DBracket
                  left: <Id.KW_DLeftBracket '[['>
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_GlobDEqual
                      left: {($ Id.VSub_DollarName flags)}
                      right: {<Id.Lit_Other '*'> <c> <Id.Lit_Other '*'>}
                    )
                  right: <Id.Lit_DRightBracket ']]'>
                  redirects: []
                )
              ]
            )
          then_kw: <Id.KW_Then then>
          action: [
            (command.Simple
              blame_tok: <print>
              more_env: []
              words: [{<print>} {<-r>} {<-->} {(SQ <'#---- Cut Here and feed the following to sh ----'>)}]
              redirects: []
              do_fork: T
            )
          ]
          spids: [1167 1181]
        )
      ]
      else_action: []
      fi_kw: <Id.KW_Fi fi>
      redirects: []
    )
    (command.Simple
      blame_tok: <cat>
      more_env: []
      words: [{<cat>}]
      redirects: [
        (Redir
          op: <Id.Redir_DLess '<<'>
          loc: (redir_loc.Fd fd:0)
          arg: 
            (redir_param.HereDoc
              here_begin: {<Id.KW_Bang '!'> <Id.KW_Bang '!'> <Id.KW_Bang '!'>}
              here_end_tok: <Id.Undefined_Tok ''>
              stdin_parts: [
                <'\n'>
                <'# This is a shell archive (produced by a ksh93 script).\n'>
                <'# Remove anything before this line, then unpack it by saving \n'>
                <'# it in a file and typing '>
                <Id.Right_DoubleQuote '"'>
                <'sh file'>
                <Id.Right_DoubleQuote '"'>
                <'.\n'>
                <'#\n'>
                <'# Wrapped by on '>
                (CommandSub
                  left_token: <Id.Left_DollarParen '$('>
                  child: 
                    (command.Simple
                      blame_tok: <date>
                      more_env: []
                      words: [{<date>}]
                      redirects: []
                      do_fork: T
                    )
                  right: <Id.Eof_RParen _>
                )
                <' by '>
                ($ Id.VSub_DollarName user)
                <'\n'>
                <'# Source directory was '>
                (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\`'> ch:'`')
                (CommandSub
                  left_token: <Id.Left_DollarParen '$('>
                  child: 
                    (command.Simple
                      blame_tok: <pwd>
                      more_env: []
                      words: [{<pwd>}]
                      redirects: []
                      do_fork: T
                    )
                  right: <Id.Eof_RParen _>
                )
                <'\'.\n'>
                <'#\n'>
                <'# This shar contains:\n'>
                <'# length   mode       name\n'>
                <'# ------   ---------- ------------------------------------------\n'>
              ]
            )
        )
      ]
      do_fork: T
    )
    (command.Simple
      blame_tok: <ls>
      more_env: []
      words: [
        {<ls>}
        {<-df>}
        {(DQ <'#%8(size)d %(mode)s %(name)s'>)}
        {($ Id.VSub_DollarName contdirs)}
        {($ Id.VSub_DollarName contents)}
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <print>
      more_env: []
      words: [{<print>} {(SQ <'\\n#\\nnocheck=$1'>)}]
      redirects: []
      do_fork: T
    )
    (command.If
      if_kw: <Id.KW_If if>
      arms: [
        (IfArm
          keyword: <Id.KW_If if>
          cond: 
            (condition.Shell
              commands: [
                (command.DBracket
                  left: <Id.KW_DLeftBracket '[['>
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_GlobDEqual
                      left: {($ Id.VSub_DollarName flags)}
                      right: {<Id.Lit_Other '*'> <Q> <Id.Lit_Other '*'>}
                    )
                  right: <Id.Lit_DRightBracket ']]'>
                  redirects: []
                )
              ]
            )
          then_kw: <Id.KW_Then then>
          action: [
            (command.Simple
              blame_tok: <print>
              more_env: []
              words: [{<print>} {<Id.Lit_VarLike 'quiet='> <Id.Lit_Colon ':'>}]
              redirects: []
              do_fork: T
            )
          ]
          spids: [1249 1263]
        )
      ]
      else_kw: <Id.KW_Else else>
      else_action: [
        (command.Simple
          blame_tok: <print>
          more_env: []
          words: [{<print>} {<Id.Lit_VarLike 'quiet='> <false>}]
          redirects: []
          do_fork: T
        )
      ]
      fi_kw: <Id.KW_Fi fi>
      redirects: []
    )
    (command.If
      if_kw: <Id.KW_If if>
      arms: [
        (IfArm
          keyword: <Id.KW_If if>
          cond: 
            (condition.Shell
              commands: [
                (command.DBracket
                  left: <Id.KW_DLeftBracket '[['>
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_GlobDEqual
                      left: {($ Id.VSub_DollarName flags)}
                      right: {<Id.Lit_Other '*'> <x> <Id.Lit_Other '*'>}
                    )
                  right: <Id.Lit_DRightBracket ']]'>
                  redirects: []
                )
              ]
            )
          then_kw: <Id.KW_Then then>
          action: [
            (command.Simple
              blame_tok: <print>
              more_env: []
              words: [{<print>} {<Id.Lit_VarLike 'nocheck='> <-c>}]
              redirects: []
              do_fork: T
            )
          ]
          spids: [1280 1294]
        )
      ]
      else_action: []
      fi_kw: <Id.KW_Fi fi>
      redirects: []
    )
    (command.If
      if_kw: <Id.KW_If if>
      arms: [
        (IfArm
          keyword: <Id.KW_If if>
          cond: 
            (condition.Shell
              commands: [
                (command.DBracket
                  left: <Id.KW_DLeftBracket '[['>
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_GlobNEqual
                      left: {($ Id.VSub_DollarName flags)}
                      right: {<Id.Lit_Other '*'> <D> <Id.Lit_Other '*'>}
                    )
                  right: <Id.Lit_DRightBracket ']]'>
                  redirects: []
                )
              ]
            )
          then_kw: <Id.KW_Then then>
          action: [
            (command.Simple
              blame_tok: <cat>
              more_env: []
              words: [{<cat>}]
              redirects: [
                (Redir
                  op: <Id.Redir_DLessDash '<<-'>
                  loc: (redir_loc.Fd fd:0)
                  arg: 
                    (redir_param.HereDoc
                      here_begin: 
                        {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\!'> ch:'!') 
                          <Id.KW_Bang '!'> <Id.KW_Bang '!'>
                        }
                      here_end_tok: <Id.Undefined_Tok ''>
                      stdin_parts: [
                        <'if\tuncompress < /dev/null > /dev/null 2>&1\n'>
                        <'then\tuncompress=\'uncompress -f\'\n'>
                        <'elif\tgunzip < /dev/null > /dev/null 2>&1\n'>
                        <'then\tuncompress=\'gunzip -f\'\n'>
                        <'fi\n'>
                        <'\n'>
                        <'if\tmd5sum /dev/null > /dev/null 2>&1\n'>
                        <'then\tmd5=md5sum\n'>
                        <'elif\tcksum -x md5 /dev/null > /dev/null 2>&1\n'>
                        <'then\tmd5=\'cksum -x md5\'\n'>
                        <'fi\n'>
                        <'\n'>
                        <'if\ttouch -am 123456789 shar$$.3 > /dev/null 2>&1 && test -f shar$$.3\n'>
                        <'then\ttouch=touch\n'>
                        <'else\ttouch=:\n'>
                        <'    echo  \'WARNING: not restoring timestamps.\'\n'>
                        <'fi\n'>
                        <'rm -f 123456789 shar$$.3\n'>
                        <'\n'>
                      ]
                    )
                )
              ]
              do_fork: T
            )
          ]
          spids: [1304 1318]
        )
      ]
      else_action: []
      fi_kw: <Id.KW_Fi fi>
      redirects: []
    )
    (command.If
      if_kw: <Id.KW_If if>
      arms: [
        (IfArm
          keyword: <Id.KW_If if>
          cond: 
            (condition.Shell
              commands: [
                (command.DBracket
                  left: <Id.KW_DLeftBracket '[['>
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_GlobDEqual
                      left: {($ Id.VSub_DollarName flags)}
                      right: {<Id.Lit_Other '*'> <X> <Id.Lit_Other '*'>}
                    )
                  right: <Id.Lit_DRightBracket ']]'>
                  redirects: []
                )
              ]
            )
          then_kw: <Id.KW_Then then>
          action: [
            (command.Simple
              blame_tok: <cat>
              more_env: []
              words: [{<cat>}]
              redirects: [
                (Redir
                  op: <Id.Redir_DLessDash '<<-'>
                  loc: (redir_loc.Fd fd:0)
                  arg: 
                    (redir_param.HereDoc
                      here_begin: 
                        {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\!'> ch:'!') 
                          <Id.KW_Bang '!'> <Id.KW_Bang '!'>
                        }
                      here_end_tok: <Id.Undefined_Tok ''>
                      stdin_parts: [
                        <'#\n'>
                        <'# The unshar will be interactively queried\n'>
                        <'#\n'>
                        <'if\ttest ! -t 2\n'>
                        <'then\texec < /dev/tty\n'>
                        <'fi\n'>
                        <'if\ttest\t"`echo -n | wc -c`" -gt 0\n'>
                        <'then\tnflag= cflag=\'\\c\'\n'>
                        <'else\tnflag=-n cflag=\n'>
                        <'fi\n'>
                      ]
                    )
                )
              ]
              do_fork: T
            )
          ]
          spids: [1351 1365]
        )
      ]
      else_action: []
      fi_kw: <Id.KW_Fi fi>
      redirects: []
    )
    (command.ShFunction
      keyword: <Id.KW_Function function>
      name_tok: <isbinary>
      name: isbinary
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.DBracket
              left: <Id.KW_DLeftBracket '[['>
              expr: 
                (bool_expr.Binary
                  op_id: Id.BoolBinary_GlobDEqual
                  left: 
                    {
                      (CommandSub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Simple
                            blame_tok: <file>
                            more_env: []
                            words: [{<file>} {<-m>} {<'/dev/null'>} {<-M>} {(DQ ($ Id.VSub_Number 1))}]
                            redirects: []
                            do_fork: T
                          )
                        right: <Id.Eof_RParen _>
                      )
                    }
                  right: 
                    {
                      (word_part.ExtGlob
                        op: <Id.ExtGlob_At '@('>
                        arms: [
                          {<Id.Lit_Other '*'> <'/ebcdic'> <Id.Lit_Other '*'>}
                          {<Id.Lit_Other '*'> <'/octet-stream'>}
                          {<Id.Lit_Other '*'> <system> <Id.Lit_Other '*'> <'/'> <Id.Lit_Other '*'>}
                        ]
                        right: <Id.Right_ExtGlob _>
                      )
                    }
                )
              right: <Id.Lit_DRightBracket ']]'>
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      keyword: <Id.KW_Function function>
      name_tok: <emit_guard>
      name: emit_guard
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <cat>
              more_env: []
              words: [{<cat>}]
              redirects: [
                (Redir
                  op: <Id.Redir_DLessDash '<<-'>
                  loc: (redir_loc.Fd fd:0)
                  arg: 
                    (redir_param.HereDoc
                      here_begin: {<Id.KW_Bang '!'> <Id.KW_Bang '!'> <Id.KW_Bang '!'>}
                      here_end_tok: <Id.Undefined_Tok ''>
                      stdin_parts: [
                        <'  echo '>
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\$'>
                          ch: '$'
                        )
                        <'nflag \'? -\' overwrite '>
                        <Id.Right_DoubleQuote '"'>
                        ($ Id.VSub_DollarName name)
                        <Id.Right_DoubleQuote '"'>
                        <' \'[no, yes, all, quit] (no)?\' '>
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\$'>
                          ch: '$'
                        )
                        <'cflag\n'>
                        <'  read check\n'>
                        <'  case '>
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\$'>
                          ch: '$'
                        )
                        <'check in\n'>
                        <'  [Aa]*)  nocheck=-c;;\n'>
                        <'  [Qq]*)  echo \'extraction aborted\';exit 1;;\n'>
                        <'  [Yy]*)\t;;\n'>
                        <'  *)\tskip=1;;\n'>
                        <'  esac\n'>
                        <'fi\n'>
                        <'if\ttest '>
                        <Id.Right_DoubleQuote '"'>
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\$'>
                          ch: '$'
                        )
                        <skip>
                        <Id.Right_DoubleQuote '"'>
                        <' = 1 \n'>
                        <'then\n'>
                      ]
                    )
                )
              ]
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      keyword: <Id.KW_Function function>
      name_tok: <makedirs>
      name: makedirs
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <typeset>
              more_env: []
              words: [{<typeset>} {<Id.Lit_VarLike 'file='> ($ Id.VSub_Number 1)}]
              redirects: []
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'file='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'file='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'file='> name:file)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (CommandSub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Simple
                            blame_tok: <dirname>
                            more_env: []
                            words: [{<dirname>} {(DQ ($ Id.VSub_DollarName file))}]
                            redirects: []
                            do_fork: T
                          )
                        right: <Id.Eof_RParen _>
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.If
              if_kw: <Id.KW_If if>
              arms: [
                (IfArm
                  keyword: <Id.KW_If if>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.DBracket
                          left: <Id.KW_DLeftBracket '[['>
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {($ Id.VSub_DollarName file)}
                              right: 
                                {
                                  (word_part.ExtGlob
                                    op: <Id.ExtGlob_At '@('>
                                    arms: [{<.>} {<'/'>} {<'//'>}]
                                    right: <Id.Right_ExtGlob _>
                                  )
                                }
                            )
                          right: <Id.Lit_DRightBracket ']]'>
                          redirects: []
                        )
                      ]
                    )
                  then_kw: <Id.KW_Then then>
                  action: [(command.ControlFlow keyword:<Id.ControlFlow_Return return>)]
                  spids: [1513 1532]
                )
              ]
              else_action: []
              fi_kw: <Id.KW_Fi fi>
              redirects: []
            )
            (command.Simple
              blame_tok: <makedirs>
              more_env: []
              words: [{<makedirs>} {(DQ ($ Id.VSub_DollarName file))}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <cat>
              more_env: []
              words: [{<cat>}]
              redirects: [
                (Redir
                  op: <Id.Redir_DLessDash '<<-'>
                  loc: (redir_loc.Fd fd:0)
                  arg: 
                    (redir_param.HereDoc
                      here_begin: {<Id.KW_Bang '!'> <Id.KW_Bang '!'> <Id.KW_Bang '!'>}
                      here_end_tok: <Id.Undefined_Tok ''>
                      stdin_parts: [
                        <'if\ttest ! -d \''>
                        ($ Id.VSub_DollarName file)
                        <'\'\n'>
                        <'then\ttest X'>
                        <Id.Right_DoubleQuote '"'>
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\$'>
                          ch: '$'
                        )
                        <quiet>
                        <Id.Right_DoubleQuote '"'>
                        <' != X &&  echo \'x -\' \''>
                        ($ Id.VSub_DollarName mkdir)
                        <'\' \''>
                        ($ Id.VSub_DollarName file)
                        <'\'\n'>
                        <'        mkdir \''>
                        ($ Id.VSub_DollarName file)
                        <'\'\n'>
                        <'fi\n'>
                      ]
                    )
                )
              ]
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      keyword: <Id.KW_Function function>
      name_tok: <pack_file>
      name: pack_file
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <typeset>
              more_env: []
              words: [{<typeset>} {<Id.Lit_VarLike 'file='> ($ Id.VSub_Number 1)}]
              redirects: []
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'filetype='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'filetype='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'filetype='> name:filetype)
                  op: assign_op.Equal
                  rhs: {<text>}
                )
                (AssignPair
                  left: <Id.Lit_VarLike 'binary='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'binary='> name:binary)
                  op: assign_op.Equal
                  rhs: (rhs_word__Empty)
                )
              ]
              redirects: []
            )
            (command.If
              if_kw: <Id.KW_If if>
              arms: [
                (IfArm
                  keyword: <Id.KW_If if>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.DBracket
                          left: <Id.KW_DLeftBracket '[['>
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_d
                              child: {($ Id.VSub_DollarName file)}
                            )
                          right: <Id.Lit_DRightBracket ']]'>
                          redirects: []
                        )
                      ]
                    )
                  then_kw: <Id.KW_Then then>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'filteype='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'filteype='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'filteype='> name:filteype)
                          op: assign_op.Equal
                          rhs: {<directory>}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [1599 1610]
                )
              ]
              else_kw: <Id.KW_Else else>
              else_action: [
                (command.Case
                  case_kw: <Id.KW_Case case>
                  to_match: (case_arg.Word w:{($ Id.VSub_DollarName mode)})
                  arms_start: <Id.KW_In in>
                  arms: [
                    (CaseArm
                      left: <B>
                      pattern: (pat.Words words:[{<B>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'filetype='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'filetype='>
                              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'filetype='> name:filetype)
                              op: assign_op.Equal
                              rhs: {<binary>}
                            )
                          ]
                          redirects: []
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <z>
                      pattern: (pat.Words words:[{<z>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'filetype='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'filetype='>
                              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'filetype='> name:filetype)
                              op: assign_op.Equal
                              rhs: {<gzipped>}
                            )
                          ]
                          redirects: []
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <Z>
                      pattern: (pat.Words words:[{<Z>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'filetype='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'filetype='>
                              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'filetype='> name:filetype)
                              op: assign_op.Equal
                              rhs: {<compressed>}
                            )
                          ]
                          redirects: []
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <M>
                      pattern: (pat.Words words:[{<M>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.If
                          if_kw: <Id.KW_If if>
                          arms: [
                            (IfArm
                              keyword: <Id.KW_If if>
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Simple
                                      blame_tok: <isbinary>
                                      more_env: []
                                      words: [{<isbinary>} {(DQ ($ Id.VSub_DollarName file))}]
                                      redirects: []
                                      do_fork: T
                                    )
                                  ]
                                )
                              then_kw: <Id.KW_Then then>
                              action: [
                                (command.ShAssignment
                                  left: <Id.Lit_VarLike 'filetype='>
                                  pairs: [
                                    (AssignPair
                                      left: <Id.Lit_VarLike 'filetype='>
                                      lhs: 
                                        (sh_lhs_expr.Name
                                          left: <Id.Lit_VarLike 'filetype='>
                                          name: filetype
                                        )
                                      op: assign_op.Equal
                                      rhs: {<binary>}
                                    )
                                  ]
                                  redirects: []
                                )
                                (command.ShAssignment
                                  left: <Id.Lit_VarLike 'binary='>
                                  pairs: [
                                    (AssignPair
                                      left: <Id.Lit_VarLike 'binary='>
                                      lhs: 
                                        (sh_lhs_expr.Name
                                          left: <Id.Lit_VarLike 'binary='>
                                          name: binary
                                        )
                                      op: assign_op.Equal
                                      rhs: {<1>}
                                    )
                                  ]
                                  redirects: []
                                )
                              ]
                              spids: [1652 1662]
                            )
                          ]
                          else_action: []
                          fi_kw: <Id.KW_Fi fi>
                          redirects: []
                        )
                      ]
                    )
                  ]
                  arms_end: <Id.KW_Esac esac>
                  redirects: []
                )
              ]
              fi_kw: <Id.KW_Fi fi>
              redirects: []
            )
            (command.If
              if_kw: <Id.KW_If if>
              arms: [
                (IfArm
                  keyword: <Id.KW_If if>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.DBracket
                          left: <Id.KW_DLeftBracket '[['>
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {($ Id.VSub_DollarName flags)}
                              right: {<Id.Lit_Other '*'> <f> <Id.Lit_Other '*'>}
                            )
                          right: <Id.Lit_DRightBracket ']]'>
                          redirects: []
                        )
                      ]
                    )
                  then_kw: <Id.KW_Then then>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'name='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'name='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'name='> name:name)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (BracedVarSub
                                left: <Id.Left_DollarBrace '${'>
                                token: <Id.VSub_Name file>
                                var_name: file
                                suffix_op: 
                                  (suffix_op.Unary
                                    op: <Id.VOp1_DPound '##'>
                                    arg_word: {<Id.Lit_Other '*'> <Id.Lit_Slash '/'>}
                                  )
                                right: <Id.Right_DollarBrace '}'>
                              )
                            }
                        )
                      ]
                      redirects: []
                    )
                    (command.AndOr
                      children: [
                        (command.DBracket
                          left: <Id.KW_DLeftBracket '[['>
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobNEqual
                              left: {($ Id.VSub_DollarName flags)}
                              right: {<Id.Lit_Other '*'> <q> <Id.Lit_Other '*'>}
                            )
                          right: <Id.Lit_DRightBracket ']]'>
                          redirects: []
                        )
                        (command.Simple
                          blame_tok: <logmsg>
                          more_env: []
                          words: [
                            {<logmsg>}
                            {
                              (DQ <'a - '> ($ Id.VSub_DollarName name) <' [from '> 
                                ($ Id.VSub_DollarName file) <'] ('> ($ Id.VSub_DollarName filetype) <')'>
                              )
                            }
                          ]
                          redirects: []
                          do_fork: T
                        )
                      ]
                      ops: [<Id.Op_DAmp _>]
                    )
                  ]
                  spids: [1685 1700]
                )
              ]
              else_kw: <Id.KW_Else else>
              else_action: [
                (command.ShAssignment
                  left: <Id.Lit_VarLike 'name='>
                  pairs: [
                    (AssignPair
                      left: <Id.Lit_VarLike 'name='>
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'name='> name:name)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName file))}
                    )
                  ]
                  redirects: []
                )
                (command.AndOr
                  children: [
                    (command.DBracket
                      left: <Id.KW_DLeftBracket '[['>
                      expr: 
                        (bool_expr.Binary
                          op_id: Id.BoolBinary_GlobNEqual
                          left: {($ Id.VSub_DollarName flags)}
                          right: {<Id.Lit_Other '*'> <q> <Id.Lit_Other '*'>}
                        )
                      right: <Id.Lit_DRightBracket ']]'>
                      redirects: []
                    )
                    (command.Simple
                      blame_tok: <logmsg>
                      more_env: []
                      words: [
                        {<logmsg>}
                        {
                          (DQ <'a - '> ($ Id.VSub_DollarName file) <' ('> 
                            ($ Id.VSub_DollarName filetype) <')'>
                          )
                        }
                      ]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  ops: [<Id.Op_DAmp _>]
                )
              ]
              fi_kw: <Id.KW_Fi fi>
              redirects: []
            )
            (command.Simple
              blame_tok: <print>
              more_env: []
              words: [
                {<print>}
                {<-r>}
                {(DQ <'# ============= '> ($ Id.VSub_DollarName file) <' =============='>)}
              ]
              redirects: []
              do_fork: T
            )
            (command.If
              if_kw: <Id.KW_If if>
              arms: [
                (IfArm
                  keyword: <Id.KW_If if>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.DBracket
                          left: <Id.KW_DLeftBracket '[['>
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {($ Id.VSub_DollarName file)}
                              right: {<Id.Lit_Other '*'> <'/'> <Id.Lit_Other '*'>}
                            )
                          right: <Id.Lit_DRightBracket ']]'>
                          redirects: []
                        )
                      ]
                    )
                  then_kw: <Id.KW_Then then>
                  action: [
                    (command.Simple
                      blame_tok: <makedirs>
                      more_env: []
                      words: [{<makedirs>} {(DQ ($ Id.VSub_DollarName file))}]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  spids: [1786 1801]
                )
              ]
              else_action: []
              fi_kw: <Id.KW_Fi fi>
              redirects: []
            )
            (command.If
              if_kw: <Id.KW_If if>
              arms: [
                (IfArm
                  keyword: <Id.KW_If if>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.DBracket
                          left: <Id.KW_DLeftBracket '[['>
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_d
                              child: {($ Id.VSub_DollarName file)}
                            )
                          right: <Id.Lit_DRightBracket ']]'>
                          redirects: []
                        )
                      ]
                    )
                  then_kw: <Id.KW_Then then>
                  action: [
                    (command.Simple
                      blame_tok: <print>
                      more_env: []
                      words: [{<print>} {(DQ <'mkdir '> ($ Id.VSub_DollarName file))}]
                      redirects: []
                      do_fork: T
                    )
                    (command.AndOr
                      children: [
                        (command.DBracket
                          left: <Id.KW_DLeftBracket '[['>
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobNEqual
                              left: {<flags>}
                              right: {<Id.Lit_Other '*'> <Q> <Id.Lit_Other '*'>}
                            )
                          right: <Id.Lit_DRightBracket ']]'>
                          redirects: []
                        )
                        (command.Simple
                          blame_tok: <print>
                          more_env: []
                          words: [{<print>} {(DQ <'echo mkdir -- '> ($ Id.VSub_DollarName file))}]
                          redirects: []
                          do_fork: T
                        )
                      ]
                      ops: [<Id.Op_DAmp _>]
                    )
                  ]
                  spids: [1817 1828]
                )
              ]
              else_kw: <Id.KW_Else else>
              else_action: [
                (command.ShAssignment
                  left: <Id.Lit_VarLike 'filetype='>
                  pairs: [
                    (AssignPair
                      left: <Id.Lit_VarLike 'filetype='>
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'filetype='> name:filetype)
                      op: assign_op.Equal
                      rhs: {<text>}
                    )
                    (AssignPair
                      left: <Id.Lit_VarLike 'binary='>
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'binary='> name:binary)
                      op: assign_op.Equal
                      rhs: (rhs_word__Empty)
                    )
                  ]
                  redirects: []
                )
                (command.Simple
                  blame_tok: <print>
                  more_env: []
                  words: [{<print>} {(SQ <'skip='>)}]
                  redirects: []
                  do_fork: T
                )
                (command.Simple
                  blame_tok: <printf>
                  more_env: []
                  words: [
                    {<printf>}
                    {
                      (DQ <if> <Id.Lit_BadBackslash '\\'> <'ttest -f %q && test '> 
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\"'>
                          ch: '"'
                        ) <X> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') <nocheck> 
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\"'>
                          ch: '"'
                        ) <' != X-c'> <Id.Lit_BadBackslash '\\'> <nthen> <Id.Lit_BadBackslash '\\'> <t>
                      )
                    }
                    {(DQ ($ Id.VSub_DollarName file))}
                  ]
                  redirects: []
                  do_fork: T
                )
                (command.If
                  if_kw: <Id.KW_If if>
                  arms: [
                    (IfArm
                      keyword: <Id.KW_If if>
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.DBracket
                              left: <Id.KW_DLeftBracket '[['>
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {($ Id.VSub_DollarName flags)}
                                  right: {<Id.Lit_Other '*'> <X> <Id.Lit_Other '*'>}
                                )
                              right: <Id.Lit_DRightBracket ']]'>
                              redirects: []
                            )
                          ]
                        )
                      then_kw: <Id.KW_Then then>
                      action: [
                        (command.Simple
                          blame_tok: <emit_guard>
                          more_env: []
                          words: [{<emit_guard>}]
                          redirects: []
                          do_fork: T
                        )
                      ]
                      spids: [1898 1913]
                    )
                  ]
                  else_action: []
                  fi_kw: <Id.KW_Fi fi>
                  redirects: []
                )
                (command.Simple
                  blame_tok: <printf>
                  more_env: []
                  words: [
                    {<printf>}
                    {
                      (DQ (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') 
                        <'quiet || '> ($ Id.VSub_DollarName skipping) <' %q '> ($ Id.VSub_DollarName exists) <Id.Lit_BadBackslash '\\'> 
                        <'nelse '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') <'quiet || '> 
                        ($ Id.VSub_DollarName extract) <' %q \'(%s)\''> <Id.Lit_BadBackslash '\\'> <n>
                      )
                    }
                    {(DQ ($ Id.VSub_DollarName file))}
                    {(DQ ($ Id.VSub_DollarName file))}
                    {(DQ ($ Id.VSub_DollarName filetype))}
                  ]
                  redirects: []
                  do_fork: T
                )
                (command.If
                  if_kw: <Id.KW_If if>
                  arms: [
                    (IfArm
                      keyword: <Id.KW_If if>
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.DBracket
                              left: <Id.KW_DLeftBracket '[['>
                              expr: 
                                (bool_expr.LogicalOr
                                  left: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobDEqual
                                      left: {($ Id.VSub_DollarName mode)}
                                      right: {<Id.Lit_Other '['> <BZz> <Id.Lit_Other ']'>}
                                    )
                                  right: (bool_expr.WordTest w:{($ Id.VSub_DollarName binary)})
                                )
                              right: <Id.Lit_DRightBracket ']]'>
                              redirects: []
                            )
                          ]
                        )
                      then_kw: <Id.KW_Then then>
                      action: [
                        (command.If
                          if_kw: <Id.KW_If if>
                          arms: [
                            (IfArm
                              keyword: <Id.KW_If if>
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.DBracket
                                      left: <Id.KW_DLeftBracket '[['>
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {($ Id.VSub_DollarName mode)}
                                          right: {<Z>}
                                        )
                                      right: <Id.Lit_DRightBracket ']]'>
                                      redirects: []
                                    )
                                  ]
                                )
                              then_kw: <Id.KW_Then then>
                              action: [
                                (command.Simple
                                  blame_tok: <compress>
                                  more_env: []
                                  words: [{<compress>} {($ Id.VSub_DollarName arg)}]
                                  redirects: [
                                    (Redir
                                      op: <Id.Redir_Less '<'>
                                      loc: (redir_loc.Fd fd:0)
                                      arg: {($ Id.VSub_DollarName file)}
                                    )
                                    (Redir
                                      op: <Id.Redir_Great '>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {<'/tmp/shar'> ($ Id.VSub_Dollar '$') <.2>}
                                    )
                                  ]
                                  do_fork: T
                                )
                                (command.ShAssignment
                                  left: <Id.Lit_VarLike 'cname='>
                                  pairs: [
                                    (AssignPair
                                      left: <Id.Lit_VarLike 'cname='>
                                      lhs: 
                                        (sh_lhs_expr.Name
                                          left: <Id.Lit_VarLike 'cname='>
                                          name: cname
                                        )
                                      op: assign_op.Equal
                                      rhs: {($ Id.VSub_DollarName name) <.Z>}
                                    )
                                  ]
                                  redirects: []
                                )
                                (command.ShAssignment
                                  left: <Id.Lit_VarLike 'dname='>
                                  pairs: [
                                    (AssignPair
                                      left: <Id.Lit_VarLike 'dname='>
                                      lhs: 
                                        (sh_lhs_expr.Name
                                          left: <Id.Lit_VarLike 'dname='>
                                          name: dname
                                        )
                                      op: assign_op.Equal
                                      rhs: {<'/tmp/shar'> ($ Id.VSub_Dollar '$') <.2>}
                                    )
                                  ]
                                  redirects: []
                                )
                              ]
                              spids: [1973 1986]
                            )
                            (IfArm
                              keyword: <Id.KW_Elif elif>
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.DBracket
                                      left: <Id.KW_DLeftBracket '[['>
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {($ Id.VSub_DollarName mode)}
                                          right: {<z>}
                                        )
                                      right: <Id.Lit_DRightBracket ']]'>
                                      redirects: []
                                    )
                                  ]
                                )
                              then_kw: <Id.KW_Then then>
                              action: [
                                (command.Simple
                                  blame_tok: <gzip>
                                  more_env: []
                                  words: [{<gzip>} {($ Id.VSub_DollarName arg)}]
                                  redirects: [
                                    (Redir
                                      op: <Id.Redir_Less '<'>
                                      loc: (redir_loc.Fd fd:0)
                                      arg: {($ Id.VSub_DollarName file)}
                                    )
                                    (Redir
                                      op: <Id.Redir_Great '>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {<'/tmp/shar'> ($ Id.VSub_Dollar '$') <.2>}
                                    )
                                  ]
                                  do_fork: T
                                )
                                (command.ShAssignment
                                  left: <Id.Lit_VarLike 'dname='>
                                  pairs: [
                                    (AssignPair
                                      left: <Id.Lit_VarLike 'dname='>
                                      lhs: 
                                        (sh_lhs_expr.Name
                                          left: <Id.Lit_VarLike 'dname='>
                                          name: dname
                                        )
                                      op: assign_op.Equal
                                      rhs: {<'/tmp/shar'> ($ Id.VSub_Dollar '$') <.2>}
                                    )
                                  ]
                                  redirects: []
                                )
                                (command.ShAssignment
                                  left: <Id.Lit_VarLike 'cname='>
                                  pairs: [
                                    (AssignPair
                                      left: <Id.Lit_VarLike 'cname='>
                                      lhs: 
                                        (sh_lhs_expr.Name
                                          left: <Id.Lit_VarLike 'cname='>
                                          name: cname
                                        )
                                      op: assign_op.Equal
                                      rhs: {($ Id.VSub_DollarName name) <.gz>}
                                    )
                                  ]
                                  redirects: []
                                )
                              ]
                              spids: [2014 2027]
                            )
                          ]
                          else_kw: <Id.KW_Else else>
                          else_action: [
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'dname='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'dname='>
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'dname='> name:dname)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName file)}
                                )
                              ]
                              redirects: []
                            )
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'cname='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'cname='>
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'cname='> name:cname)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName name)}
                                )
                              ]
                              redirects: []
                            )
                          ]
                          fi_kw: <Id.KW_Fi fi>
                          redirects: []
                        )
                        (command.Simple
                          blame_tok: <print>
                          more_env: []
                          words: [{<print>} {<-r>} {(SQ <'uudecode  << \\!!!!'>)}]
                          redirects: []
                          do_fork: T
                        )
                        (command.Simple
                          blame_tok: <uuencode>
                          more_env: []
                          words: [{<uuencode>} {(DQ ($ Id.VSub_DollarName cname))}]
                          redirects: [
                            (Redir
                              op: <Id.Redir_Less '<'>
                              loc: (redir_loc.Fd fd:0)
                              arg: {($ Id.VSub_DollarName dname)}
                            )
                          ]
                          do_fork: T
                        )
                        (command.Simple
                          blame_tok: <print>
                          more_env: []
                          words: [{<print>} {(DQ <'!!!!'>)}]
                          redirects: []
                          do_fork: T
                        )
                        (command.If
                          if_kw: <Id.KW_If if>
                          arms: [
                            (IfArm
                              keyword: <Id.KW_If if>
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.DBracket
                                      left: <Id.KW_DLeftBracket '[['>
                                      expr: 
                                        (bool_expr.LogicalAnd
                                          left: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: {($ Id.VSub_DollarName mode)}
                                              right: {<Z>}
                                            )
                                          right: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobNEqual
                                              left: {<flags>}
                                              right: {<Id.Lit_Other '*'> <Q> <Id.Lit_Other '*'>}
                                            )
                                        )
                                      right: <Id.Lit_DRightBracket ']]'>
                                      redirects: []
                                    )
                                  ]
                                )
                              then_kw: <Id.KW_Then then>
                              action: [
                                (command.Simple
                                  blame_tok: <printf>
                                  more_env: []
                                  words: [
                                    {<printf>}
                                    {
                                      (DQ <'echo \''> ($ Id.VSub_DollarName uncomp) <'\' %s'> 
                                        <Id.Lit_BadBackslash '\\'> <n> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') <'uncompress  %q'> 
                                        <Id.Lit_BadBackslash '\\'> <n>
                                      )
                                    }
                                    {(DQ ($ Id.VSub_DollarName file))}
                                    {(DQ ($ Id.VSub_DollarName cname))}
                                  ]
                                  redirects: []
                                  do_fork: T
                                )
                              ]
                              spids: [2095 2118]
                            )
                            (IfArm
                              keyword: <Id.KW_Elif elif>
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.DBracket
                                      left: <Id.KW_DLeftBracket '[['>
                                      expr: 
                                        (bool_expr.LogicalAnd
                                          left: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: {($ Id.VSub_DollarName mode)}
                                              right: {<z>}
                                            )
                                          right: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobNEqual
                                              left: {<flags>}
                                              right: {<Id.Lit_Other '*'> <Q> <Id.Lit_Other '*'>}
                                            )
                                        )
                                      right: <Id.Lit_DRightBracket ']]'>
                                      redirects: []
                                    )
                                  ]
                                )
                              then_kw: <Id.KW_Then then>
                              action: [
                                (command.Simple
                                  blame_tok: <printf>
                                  more_env: []
                                  words: [
                                    {<printf>}
                                    {
                                      (DQ <'echo \''> ($ Id.VSub_DollarName uncomp) <'\' %s'> 
                                        <Id.Lit_BadBackslash '\\'> <'ngunzip  %q'> <Id.Lit_BadBackslash '\\'> <n>
                                      )
                                    }
                                    {(DQ ($ Id.VSub_DollarName file))}
                                    {(DQ ($ Id.VSub_DollarName cname))}
                                  ]
                                  redirects: []
                                  do_fork: T
                                )
                              ]
                              spids: [2143 2166]
                            )
                          ]
                          else_action: []
                          fi_kw: <Id.KW_Fi fi>
                          redirects: []
                        )
                      ]
                      spids: [1952 1971]
                    )
                  ]
                  else_kw: <Id.KW_Else else>
                  else_action: [
                    (command.Simple
                      blame_tok: <print>
                      more_env: []
                      words: [
                        {<print>}
                        {<-r>}
                        {
                          (DQ <'sed \'s/^@//\' > '> 
                            (word_part.EscapedLiteral
                              token: <Id.Lit_EscapedChar '\\"'>
                              ch: '"'
                            ) ($ Id.VSub_DollarName name) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"') 
                            <' <<\''> ($ Id.VSub_DollarName separator) <'\''>
                          )
                        }
                      ]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <sed>
                      more_env: []
                      words: [
                        {<sed>}
                        {<-e>}
                        {(SQ <'s/^[.~@]/@&/'>)}
                        {<-e>}
                        {(SQ <'s/^From/@&/'>)}
                        {(DQ ($ Id.VSub_DollarName file))}
                      ]
                      redirects: []
                      do_fork: T
                    )
                    (command.Simple
                      blame_tok: <print>
                      more_env: []
                      words: [{<print>} {<-r>} {($ Id.VSub_DollarName separator)}]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  fi_kw: <Id.KW_Fi fi>
                  redirects: []
                )
              ]
              fi_kw: <Id.KW_Fi fi>
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'fmode='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'fmode='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'fmode='> name:fmode)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (CommandSub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Simple
                            blame_tok: <ls>
                            more_env: []
                            words: [{<ls>} {<-df>} {(DQ <'%(mode)s'>)} {(DQ ($ Id.VSub_DollarName file))}]
                            redirects: []
                            do_fork: T
                          )
                        right: <Id.Eof_RParen _>
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'fmode='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'fmode='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'fmode='> name:fmode)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (BracedVarSub
                        left: <Id.Left_DollarBrace '${'>
                        token: <Id.VSub_Name fmode>
                        var_name: fmode
                        suffix_op: 
                          (suffix_op.PatSub
                            pat: 
                              {<Id.Lit_Other '?'> 
                                (word_part.ExtGlob
                                  op: <Id.ExtGlob_At '@('>
                                  arms: [{<Id.Lit_Other '?'> <Id.Lit_Other '?'> <Id.Lit_Other '?'>}]
                                  right: <Id.Right_ExtGlob _>
                                ) 
                                (word_part.ExtGlob
                                  op: <Id.ExtGlob_At '@('>
                                  arms: [{<Id.Lit_Other '?'> <Id.Lit_Other '?'> <Id.Lit_Other '?'>}]
                                  right: <Id.Right_ExtGlob _>
                                ) 
                                (word_part.ExtGlob
                                  op: <Id.ExtGlob_At '@('>
                                  arms: [{<Id.Lit_Other '?'> <Id.Lit_Other '?'> <Id.Lit_Other '?'>}]
                                  right: <Id.Right_ExtGlob _>
                                )
                              }
                            replace: 
                              {<'u='> 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\1'>
                                  ch: 1
                                ) <',g='> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\2'> ch:2) <',o='> 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\3'>
                                  ch: 3
                                )
                              }
                            replace_mode: Id.Undefined_Tok
                            slash_tok: <Id.VOp2_Slash _>
                          )
                        right: <Id.Right_DollarBrace '}'>
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'mtime='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'mtime='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'mtime='> name:mtime)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (CommandSub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Simple
                            blame_tok: <date>
                            more_env: []
                            words: [
                              {<date>}
                              {<-m>}
                              {<-f>}
                              {<Id.Lit_Other '%'> <Id.Lit_Pound '#'>}
                              {(DQ ($ Id.VSub_DollarName file))}
                            ]
                            redirects: []
                            do_fork: T
                          )
                        right: <Id.Eof_RParen _>
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <printf>
              more_env: []
              words: [
                {<printf>}
                {
                  (DQ <'chmod '> 
                    (BracedVarSub
                      left: <Id.Left_DollarBrace '${'>
                      token: <Id.VSub_Name fmode>
                      var_name: fmode
                      suffix_op: 
                        (suffix_op.PatSub
                          pat: {<->}
                          replace: (rhs_word__Empty)
                          replace_mode: Id.Lit_Slash
                          slash_tok: <Id.VOp2_Slash _>
                        )
                      right: <Id.Right_DollarBrace '}'>
                    ) <' %q&&'> <Id.Lit_BadBackslash '\\'> <n> <Id.Lit_BadBackslash '\\'> <t> 
                    (word_part.EscapedLiteral
                      token: <Id.Lit_EscapedChar '\\$'>
                      ch: '$'
                    ) <'touch -am '> ($ Id.VSub_DollarName mtime) <' %q'> <Id.Lit_BadBackslash '\\'> <n>
                  )
                }
                {(DQ ($ Id.VSub_DollarName name))}
                {(DQ ($ Id.VSub_DollarName name))}
              ]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <print>
              more_env: []
              words: [{<print>} {(DQ <fi>)}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.If
      if_kw: <Id.KW_If if>
      arms: [
        (IfArm
          keyword: <Id.KW_If if>
          cond: 
            (condition.Shell
              commands: [
                (command.DBracket
                  left: <Id.KW_DLeftBracket '[['>
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_GlobDEqual
                      left: {($ Id.VSub_DollarName flags)}
                      right: {<Id.Lit_Other '*'> <S> <Id.Lit_Other '*'>}
                    )
                  right: <Id.Lit_DRightBracket ']]'>
                  redirects: []
                )
              ]
            )
          then_kw: <Id.KW_Then then>
          action: [
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Simple
                      blame_tok: <read>
                      more_env: []
                      words: [{<read>} {<-r>} {<file>}]
                      redirects: []
                      do_fork: T
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  left: <Id.KW_Do do>
                  children: [
                    (command.Simple
                      blame_tok: <pack_file>
                      more_env: []
                      words: [{<pack_file>} {(DQ ($ Id.VSub_DollarName file))}]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  right: <Id.KW_Done done>
                )
              redirects: [
                (Redir
                  op: <Id.Redir_Less '<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: {<'/tmp/shar'> ($ Id.VSub_Dollar '$') <.3>}
                )
              ]
            )
          ]
          spids: [2354 2368]
        )
      ]
      else_kw: <Id.KW_Else else>
      else_action: [
        (command.ForEach
          keyword: <Id.KW_For for>
          iter_names: [file]
          iterable: (for_iter__Args)
          body: 
            (command.DoGroup
              left: <Id.KW_Do do>
              children: [
                (command.Simple
                  blame_tok: <pack_file>
                  more_env: []
                  words: [{<pack_file>} {(DQ ($ Id.VSub_DollarName file))}]
                  redirects: []
                  do_fork: T
                )
              ]
              right: <Id.KW_Done done>
            )
          redirects: []
        )
      ]
      fi_kw: <Id.KW_Fi fi>
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'files='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'files='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'files='> name:files)
          op: assign_op.Equal
          rhs: 
            {
              (CommandSub
                left_token: <Id.Left_DollarParen '$('>
                child: 
                  (command.Simple
                    blame_tok: <printf>
                    more_env: []
                    words: [{<printf>} {(DQ <'%q '>)} {($ Id.VSub_DollarName contents)}]
                    redirects: []
                    do_fork: T
                  )
                right: <Id.Eof_RParen _>
              )
            }
        )
      ]
      redirects: []
    )
    (command.If
      if_kw: <Id.KW_If if>
      arms: [
        (IfArm
          keyword: <Id.KW_If if>
          cond: 
            (condition.Shell
              commands: [
                (command.DBracket
                  left: <Id.KW_DLeftBracket '[['>
                  expr: 
                    (bool_expr.LogicalAnd
                      left: 
                        (bool_expr.Binary
                          op_id: Id.BoolBinary_GlobNEqual
                          left: {($ Id.VSub_DollarName flags)}
                          right: {<Id.Lit_Other '*'> <w> <Id.Lit_Other '*'>}
                        )
                      right: 
                        (bool_expr.Binary
                          op_id: Id.BoolBinary_GlobNEqual
                          left: {($ Id.VSub_DollarName flags)}
                          right: {<Id.Lit_Other '*'> <D> <Id.Lit_Other '*'>}
                        )
                    )
                  right: <Id.Lit_DRightBracket ']]'>
                  redirects: []
                )
              ]
            )
          then_kw: <Id.KW_Then then>
          action: [
            (command.Simple
              blame_tok: <cat>
              more_env: []
              words: [{<cat>}]
              redirects: [
                (Redir
                  op: <Id.Redir_DLessDash '<<-'>
                  loc: (redir_loc.Fd fd:0)
                  arg: 
                    (redir_param.HereDoc
                      here_begin: {<__END__>}
                      here_end_tok: <Id.Undefined_Tok ''>
                      stdin_parts: [
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\$'>
                          ch: '$'
                        )
                        <'quiet || echo \'Inspecting for damage in transit...\'\n'>
                        <'temp=/tmp/shar'>
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\$'>
                          ch: '$'
                        )
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\$'>
                          ch: '$'
                        )
                        <'; dtemp=/tmp/.shar'>
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\$'>
                          ch: '$'
                        )
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\$'>
                          ch: '$'
                        )
                        <'\n'>
                        <'trap '>
                        <Id.Right_DoubleQuote '"'>
                        <'rm -f '>
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\$'>
                          ch: '$'
                        )
                        <'temp '>
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\$'>
                          ch: '$'
                        )
                        <'dtemp; exit'>
                        <Id.Right_DoubleQuote '"'>
                        <' EXIT HUP INT QUIT TERM\n'>
                        <'if\t[ X'>
                        <Id.Right_DoubleQuote '"'>
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\$'>
                          ch: '$'
                        )
                        <md5>
                        <Id.Right_DoubleQuote '"'>
                        <' != X ]\n'>
                        <'then\tcat > '>
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\$'>
                          ch: '$'
                        )
                        <'temp <<'>
                        <Id.Lit_BadBackslash '\\'>
                        <'!!!\n'>
                        (CommandSub
                          left_token: <Id.Left_DollarParen '$('>
                          child: 
                            (command.If
                              if_kw: <Id.KW_If if>
                              arms: [
                                (IfArm
                                  keyword: <Id.KW_If if>
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.DBracket
                                          left: <Id.KW_DLeftBracket '[['>
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: {($ Id.VSub_DollarName flags)}
                                              right: {<Id.Lit_Other '*'> <b> <Id.Lit_Other '*'>}
                                            )
                                          right: <Id.Lit_DRightBracket ']]'>
                                          redirects: []
                                        )
                                      ]
                                    )
                                  then_kw: <Id.KW_Then then>
                                  action: [
                                    (command.Pipeline
                                      children: [
                                        (command.Simple
                                          blame_tok: <cksum>
                                          more_env: []
                                          words: [{<cksum>} {<-x>} {<md5>} {(DQ ($ Id.VSub_At '@'))}]
                                          redirects: []
                                          do_fork: T
                                        )
                                        (command.Simple
                                          blame_tok: <sed>
                                          more_env: []
                                          words: [{<sed>} {(SQ <'s=[^ ]*/=='>)}]
                                          redirects: []
                                          do_fork: T
                                        )
                                      ]
                                      ops: [<Id.Op_Pipe _>]
                                    )
                                  ]
                                  spids: [2498 2512]
                                )
                              ]
                              else_kw: <Id.KW_Else else>
                              else_action: [
                                (command.Pipeline
                                  children: [
                                    (command.Simple
                                      blame_tok: <cksum>
                                      more_env: []
                                      words: [{<cksum>} {<-x>} {<md5>} {($ Id.VSub_DollarName contents)}]
                                      redirects: []
                                      do_fork: T
                                    )
                                    (command.Simple
                                      blame_tok: <sed>
                                      more_env: []
                                      words: [{<sed>} {(SQ <'s=[^ ]*/=='>)}]
                                      redirects: []
                                      do_fork: T
                                    )
                                  ]
                                  ops: [<Id.Op_Pipe _>]
                                )
                              ]
                              fi_kw: <Id.KW_Fi fi>
                              redirects: []
                            )
                          right: <Id.Eof_RParen _>
                        )
                        <'\n'>
                        <'!!!\n'>
                        <'cksum=\'cksum -x md5\'\n'>
                        <'else\tcat > '>
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\$'>
                          ch: '$'
                        )
                        <'temp <<'>
                        <Id.Lit_BadBackslash '\\'>
                        <'!!!\n'>
                        (CommandSub
                          left_token: <Id.Left_DollarParen '$('>
                          child: 
                            (command.CommandList
                              children: [
                                (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: 
                                        {
                                          (SingleQuoted
                                            left: <Id.Left_DollarSingleQuote '$\''>
                                            tokens: [<Id.Char_OneChar '\\n'>]
                                            right: <Id.Right_SingleQuote '\''>
                                          )
                                        }
                                    )
                                  ]
                                  redirects: []
                                )
                                (command.If
                                  if_kw: <Id.KW_If if>
                                  arms: [
                                    (IfArm
                                      keyword: <Id.KW_If if>
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.DBracket
                                              left: <Id.KW_DLeftBracket '[['>
                                              expr: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_GlobDEqual
                                                  left: {($ Id.VSub_DollarName flags)}
                                                  right: {<Id.Lit_Other '*'> <b> <Id.Lit_Other '*'>}
                                                )
                                              right: <Id.Lit_DRightBracket ']]'>
                                              redirects: []
                                            )
                                          ]
                                        )
                                      then_kw: <Id.KW_Then then>
                                      action: [
                                        (command.Pipeline
                                          children: [
                                            (command.Simple
                                              blame_tok: <wc>
                                              more_env: []
                                              words: [{<wc>} {(DQ ($ Id.VSub_At '@'))}]
                                              redirects: []
                                              do_fork: T
                                            )
                                            (command.Simple
                                              blame_tok: <sed>
                                              more_env: []
                                              words: [{<sed>} {(SQ <'s=[^ ]*/=='>)}]
                                              redirects: []
                                              do_fork: T
                                            )
                                          ]
                                          ops: [<Id.Op_Pipe _>]
                                        )
                                      ]
                                      spids: [2572 2586]
                                    )
                                  ]
                                  else_kw: <Id.KW_Else else>
                                  else_action: [
                                    (command.Pipeline
                                      children: [
                                        (command.Simple
                                          blame_tok: <wc>
                                          more_env: []
                                          words: [{<wc>} {($ Id.VSub_DollarName contents)}]
                                          redirects: []
                                          do_fork: T
                                        )
                                        (command.Simple
                                          blame_tok: <sed>
                                          more_env: []
                                          words: [{<sed>} {(SQ <'s=[^ ]*/=='>)}]
                                          redirects: []
                                          do_fork: T
                                        )
                                      ]
                                      ops: [<Id.Op_Pipe _>]
                                    )
                                  ]
                                  fi_kw: <Id.KW_Fi fi>
                                  redirects: []
                                )
                              ]
                            )
                          right: <Id.Eof_RParen _>
                        )
                        <'\n'>
                        <'!!!\n'>
                        <'cksum=wc\n'>
                        <'fi\n'>
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\$'>
                          ch: '$'
                        )
                        <'cksum '>
                        ($ Id.VSub_DollarName files)
                        <' | sed \'s=[^ ]*/==\' | diff -b '>
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\$'>
                          ch: '$'
                        )
                        <'temp - >'>
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\$'>
                          ch: '$'
                        )
                        <'dtemp\n'>
                        <'if\t[ -s '>
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\$'>
                          ch: '$'
                        )
                        <'dtemp ]\n'>
                        <'then\techo '>
                        <Id.Right_DoubleQuote '"'>
                        <'Ouch [diff of '>
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\$'>
                          ch: '$'
                        )
                        <'cksum output]:'>
                        <Id.Right_DoubleQuote '"'>
                        <' ; cat '>
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\$'>
                          ch: '$'
                        )
                        <'dtemp\n'>
                        <'else\t'>
                        (word_part.EscapedLiteral
                          token: <Id.Lit_EscapedChar '\\$'>
                          ch: '$'
                        )
                        <'quiet || echo '>
                        <Id.Right_DoubleQuote '"'>
                        <'No problems found.'>
                        <Id.Right_DoubleQuote '"'>
                        <'\n'>
                        <'fi\n'>
                      ]
                    )
                )
              ]
              do_fork: T
            )
          ]
          spids: [2435 2459]
        )
      ]
      else_action: []
      fi_kw: <Id.KW_Fi fi>
      redirects: []
    )
    (command.If
      if_kw: <Id.KW_If if>
      arms: [
        (IfArm
          keyword: <Id.KW_If if>
          cond: 
            (condition.Shell
              commands: [
                (command.DBracket
                  left: <Id.KW_DLeftBracket '[['>
                  expr: (bool_expr.WordTest w:{($ Id.VSub_DollarName prefix)})
                  right: <Id.Lit_DRightBracket ']]'>
                  redirects: []
                )
              ]
            )
          then_kw: <Id.KW_Then then>
          action: [
            (command.If
              if_kw: <Id.KW_If if>
              arms: [
                (IfArm
                  keyword: <Id.KW_If if>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.DBracket
                          left: <Id.KW_DLeftBracket '[['>
                          expr: (bool_expr.WordTest w:{($ Id.VSub_DollarName split)})
                          right: <Id.Lit_DRightBracket ']]'>
                          redirects: []
                        )
                      ]
                    )
                  then_kw: <Id.KW_Then then>
                  action: [
                    (command.Simple
                      blame_tok: <split>
                      more_env: []
                      words: [
                        {<split>}
                        {<-b>}
                        {($ Id.VSub_DollarName size)}
                        {<-f>}
                        {(DQ ($ Id.VSub_DollarName prefix))}
                        {<'/tmp/shar'> ($ Id.VSub_Dollar '$') <.1>}
                      ]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  spids: [2670 2679]
                )
                (IfArm
                  keyword: <Id.KW_Elif elif>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.DParen
                          left: <Id.Op_DLeftParen _>
                          child: 
                            (arith_expr.Binary
                              op_id: Id.Arith_DAmp
                              left: {($ Id.VSub_DollarName size)}
                              right: 
                                (arith_expr.Binary
                                  op_id: Id.Arith_Great
                                  left: 
                                    {
                                      (CommandSub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (command.Simple
                                            blame_tok: <wc>
                                            more_env: []
                                            words: [{<wc>} {<-c>}]
                                            redirects: [
                                              (Redir
                                                op: <Id.Redir_Less '<'>
                                                loc: (redir_loc.Fd fd:0)
                                                arg: {<'/tmp/shar'> ($ Id.VSub_Dollar '$') <.1>}
                                              )
                                            ]
                                            do_fork: T
                                          )
                                        right: <Id.Eof_RParen _>
                                      )
                                    }
                                  right: {($ Id.VSub_DollarName size)}
                                )
                            )
                          right: <Id.Op_DRightParen _>
                          redirects: []
                        )
                      ]
                    )
                  then_kw: <Id.KW_Then then>
                  action: [
                    (command.Simple
                      blame_tok: <head>
                      more_env: []
                      words: [
                        {<head>}
                        {<-c>}
                        {($ Id.VSub_DollarName size)}
                        {<'/tmp/shar'> ($ Id.VSub_Dollar '$') <.1>}
                      ]
                      redirects: [
                        (Redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {($ Id.VSub_DollarName prefix) <.01>}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  spids: [2698 2726]
                )
              ]
              else_kw: <Id.KW_Else else>
              else_action: [
                (command.Simple
                  blame_tok: <cp>
                  more_env: []
                  words: [
                    {<cp>}
                    {<'/tmp/shar'> ($ Id.VSub_Dollar '$') <.1>}
                    {(DQ ($ Id.VSub_DollarName prefix) <.01>)}
                  ]
                  redirects: []
                  do_fork: T
                )
              ]
              fi_kw: <Id.KW_Fi fi>
              redirects: []
            )
          ]
          spids: [2660 2668]
        )
      ]
      else_action: []
      fi_kw: <Id.KW_Fi fi>
      redirects: []
    )
    (command.Simple
      blame_tok: <print>
      more_env: []
      words: [{<print>} {(SQ <'exit 0'>)}]
      redirects: []
      do_fork: T
    )
  ]
)