(command.CommandList
  children: [
    (command.Simple
      blame_tok: <Id.Lit_Colon ':'>
      more_env: []
      words: [{<Id.Lit_Colon ':'>}]
      redirects: []
      do_fork: T
    )
    (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: {<crontab>}
        )
      ]
      redirects: []
    )
    (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: 
            {
              (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.Case
      case_kw: <Id.KW_Case case>
      to_match: (case_arg.Word w:{($ Id.VSub_DollarName prefix)})
      arms_start: <Id.KW_In in>
      arms: [
        (CaseArm
          left: <Id.Lit_Star '*'>
          pattern: (pat.Words words:[{<Id.Lit_Star '*'> <Id.Lit_Underscore _> <Id.Lit_Star '*'>}])
          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: 
                    {
                      (BracedVarSub
                        left: <Id.Left_DollarBrace '${'>
                        token: <Id.VSub_Name prefix>
                        var_name: prefix
                        suffix_op: 
                          (suffix_op.Unary
                            op: <Id.VOp1_DPercent '%%'>
                            arg_word: {<_> <Id.Lit_Other '*'>}
                          )
                        right: <Id.Right_DollarBrace '}'>
                      ) <Id.Lit_Underscore _>
                    }
                )
              ]
              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 '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: (rhs_word__Empty)
                )
              ]
              redirects: []
            )
          ]
          right: <Id.Op_DSemi _>
        )
      ]
      arms_end: <Id.KW_Esac esac>
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'cron='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'cron='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'cron='> name:cron)
          op: assign_op.Equal
          rhs: {(DQ (${ Id.VSub_Name prefix) <'at -qc'>)}
        )
      ]
      redirects: []
    )
    (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: {($ Id.VSub_DollarName HOME) <'/.'> ($ Id.VSub_DollarName command)}
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'replace='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'replace='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'replace='> name:replace)
          op: assign_op.Equal
          rhs: (rhs_word__Empty)
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'temp='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'temp='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'temp='> name:temp)
          op: assign_op.Equal
          rhs: 
            {
              (BracedVarSub
                left: <Id.Left_DollarBrace '${'>
                token: <Id.VSub_Name TMPDIR>
                var_name: TMPDIR
                suffix_op: 
                  (suffix_op.Unary
                    op: <Id.VTest_ColonHyphen _>
                    arg_word: {<Id.Lit_Slash '/'> <tmp>}
                  )
                right: <Id.Right_DollarBrace '}'>
              ) <'/cron'> ($ Id.VSub_Dollar '$')
            }
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike 'op='>
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike 'op='>
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'op='> name:op)
          op: assign_op.Equal
          rhs: (rhs_word__Empty)
        )
      ]
      redirects: []
    )
    (command.Case
      case_kw: <Id.KW_Case case>
      to_match: 
        (case_arg.Word
          w: 
            {
              (CommandSub
                left_token: <Id.Left_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: crontab (AT&T Labs Research) 2006-05-17 $\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 '[+NAME?crontab - schedule periodic background work]\n'>
                          <Id.Char_Literals '[+DESCRIPTION?'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals crontab>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' creates, replaces or edits the calling user crontab\n'>
                          <Id.Char_Literals 
'\tentry; a crontab entry is a list of commands and the times at which\n'
                          >
                          <Id.Char_Literals 
'\tthey are to be executed. The new crontab entry can be input by\n'
                          >
                          <Id.Char_Literals '\tspecifying '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals file>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ', or input from standard input if '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals file>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ' is\n'>
                          <Id.Char_Literals '\tomitted, or by using an editor, if '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals --edit>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' is specified. The\n'>
                          <Id.Char_Literals '\tactual crontab entry is maintained in the file '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '$HOME/.crontab'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '.]\n'>
                          <Id.Char_Literals 
'[+?Upon execution of a command from a crontab entry, the implementation will\n'
                          >
                          <Id.Char_Literals 
'\tsupply a default environment, defining at least the following\n'
                          >
                          <Id.Char_Literals '\tenvironment variables:]{\n'>
                          <Id.Char_Literals 
'\t[+HOME?A pathname of the calling user home directory.]\n'
                          >
                          <Id.Char_Literals '\t[+LOGNAME?The calling user login name.]\n'>
                          <Id.Char_Literals 
'\t[+PATH?A string representing a search path guaranteed to find all\n'
                          >
                          <Id.Char_Literals '\t\tof the standard utilities.]\n'>
                          <Id.Char_Literals '\t[+SHELL?A pathname of the command interpreter '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals sh>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1).]\n'>
                          <Id.Char_Literals '}\n'>
                          <Id.Char_Literals 
'[+?If standard output and standard error are not redirected by commands\n'
                          >
                          <Id.Char_Literals 
'\texecuted from the crontab entry, any generated output or errors will\n'
                          >
                          <Id.Char_Literals '\tbe mailed to the calling user.]\n'>
                          <Id.Char_Literals '[+?Users are permitted to use '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals crontab>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' if their names appear in the file\n'>
                          <Id.Char_Literals '\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '/usr/lib/cron/cron.allow'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '. If that file does not exist, the file\n'>
                          <Id.Char_Literals '\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '/usr/lib/cron/cron.deny'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' is checked to determine if the calling user\n'>
                          <Id.Char_Literals '\tshould be denied access to '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals crontab>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '. If neither file exists, only\n'>
                          <Id.Char_Literals 
'\ta process with appropriate privileges is allowed to submit a job. If\n'
                          >
                          <Id.Char_Literals '\tonly '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals cron.deny>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' exists and is empty, global usage is permitted. The\n'>
                          <Id.Char_Literals '\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals cron.allow>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' and '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals cron.deny>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' files consist of one user name per\n'>
                          <Id.Char_Literals '\tline.]\n'>
                          <Id.Char_Literals '[+?In this implementation, each command in the '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals crontab>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' file represents\n'>
                          <Id.Char_Literals '\ta single '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals at>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals job>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals '. Only one job per command will be executed.\n'>
                          <Id.Char_Literals 
'\tA new job for a given command will not be scheduled until the previous\n'
                          >
                          <Id.Char_Literals '\tjob for that command, if any, has exited.]\n'>
                          <Id.Char_Literals 
'[e:edit?Edit a copy of the calling user crontab entry, or create an empty\n'
                          >
                          <Id.Char_Literals 
'\tentry to edit if the crontab entry does not exist. When editing is\n'
                          >
                          <Id.Char_Literals 
'\tcomplete, the entry will be installed as the calling user crontab\n'
                          >
                          <Id.Char_Literals '\tentry. The editor used is defined by the '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals EDITOR>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' environment\n'>
                          <Id.Char_Literals '\tvariable. The default editor is '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals vi>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1).]\n'>
                          <Id.Char_Literals '[l:list?List the calling user crontab entry.]\n'>
                          <Id.Char_Literals 
'[r:remove|delete?Remove the calling user crontab entry.]\n'
                          >
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals '[ file ]\n'>
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals 
'[+INPUT FILES?A crontab entry must be a text file consisting of lines of six\n'
                          >
                          <Id.Char_Literals 
'\tfields each. The fields must be separated by blank characters. The\n'
                          >
                          <Id.Char_Literals 
'\tfirst five fields must be integer patterns that specify the\n'
                          >
                          <Id.Char_Literals '\tfollowing:]{\n'>
                          <Id.Char_Literals '\t[+1.?Minute (0-59)]\n'>
                          <Id.Char_Literals '\t[+2.?Hour (0-23)]\n'>
                          <Id.Char_Literals '\t[+3.?Day of the month (1-31)]\n'>
                          <Id.Char_Literals '\t[+4.?Month of the year (1-12)]\n'>
                          <Id.Char_Literals '\t[+5.?Day of the week (0-6 with 0=Sunday)]\n'>
                          <Id.Char_Literals '}\n'>
                          <Id.Char_Literals 
'[+?Each of these patterns can be either an asterisk (meaning all valid\n'
                          >
                          <Id.Char_Literals 
'\tvalues), an element or a list of elements separated by commas.\n'
                          >
                          <Id.Char_Literals 
'\tAn element must be either a number or two numbers separated by a\n'
                          >
                          <Id.Char_Literals 
'\thyphen (meaning an inclusive range). The specification of days can\n'
                          >
                          <Id.Char_Literals 
'\tbe made by two fields (day of the month and day of the week). If\n'
                          >
                          <Id.Char_Literals 
'\tmonth, day of month and day of week are all asterisks, every day\n'
                          >
                          <Id.Char_Literals 
'\twill be matched. If either the month or day of month is specified\n'
                          >
                          <Id.Char_Literals 
'\tas an element or list, but the day of week is an asterisk, the\n'
                          >
                          <Id.Char_Literals 
'\tmonth and day of month fields will specify the days that match. If\n'
                          >
                          <Id.Char_Literals 
'\tboth month and day of month are specified as asterisk, but day of\n'
                          >
                          <Id.Char_Literals 
'\tweek is an element or list, then only the specified days of the\n'
                          >
                          <Id.Char_Literals 
'\tweek will match. Finally, if either the month or day of month is\n'
                          >
                          <Id.Char_Literals 
'\tspecified as an element or list, and the day of week is also\n'
                          >
                          <Id.Char_Literals 
'\tspecified as an element or list, then any day matching either the\n'
                          >
                          <Id.Char_Literals 
'\tmonth and day of month or the day of week, will be matched.]\n'
                          >
                          <Id.Char_Literals 
'[+?The sixth field of a line in a crontab entry is a string that will\n'
                          >
                          <Id.Char_Literals '\tbe executed by '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals sh>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' at the specified times.  A percent sign character\n'>
                          <Id.Char_Literals 
'\tin this field will be translated to a newline character. Any\n'
                          >
                          <Id.Char_Literals 
'\tcharacter preceded by a backslash (including the %) causes that\n'
                          >
                          <Id.Char_Literals 
'\tcharacter to be treated literally. Only the first line (up to a "%"\n'
                          >
                          <Id.Char_Literals 
'\tor end-of-line) of the command field will be executed by the\n'
                          >
                          <Id.Char_Literals 
'\tcommand interpreter. The other lines will be made available to the\n'
                          >
                          <Id.Char_Literals '\tcommand as standard input.]\n'>
                          <Id.Char_Literals 
'[+?A job label is generated by a readable hash of the command. If the first\n'
                          >
                          <Id.Char_Literals '\tcharacters are '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ':'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals label>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ';'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' then the job label will be set to\n'>
                          <Id.Char_Literals '\t'>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals label>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ' verbatim. Job labels are limited to 12 characters.]\n'>
                          <Id.Char_Literals 
'[+?Blank lines and those whose first non-blank character is "#" will\n'
                          >
                          <Id.Char_Literals '\tbe ignored.]\n'>
                          <Id.Char_Literals '[+FILES]{\n'>
                          <Id.Char_Literals 
'\t[+$HOME/.crontab?Edited per-user crontab entry file.]\n'
                          >
                          <Id.Char_Literals '}\n'>
                          <Id.Char_Literals '[+SEE ALSO?'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals at>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1), '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals batch>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1), '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals sh>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1)]\n'>
                        ]
                        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 <'elr [ file ]'>)}
                )
              ]
              redirects: []
            )
          ]
          right: <Id.Op_DSemi _>
        )
      ]
      arms_end: <Id.KW_Esac esac>
      redirects: []
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: 
        (condition.Shell
          commands: [
            (command.Simple
              blame_tok: <getopts>
              more_env: []
              words: [{<getopts>} {(DQ ($ Id.VSub_DollarName usage))} {<OPT>}]
              redirects: []
              do_fork: T
            )
          ]
        )
      body: 
        (command.DoGroup
          left: <Id.KW_Do do>
          children: [
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_DollarName OPT)})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <e>
                  pattern: (pat.Words words:[{<e>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'op='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'op='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'op='> name:op)
                          op: assign_op.Equal
                          rhs: {<edit>}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <l>
                  pattern: (pat.Words words:[{<l>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'op='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'op='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'op='> name:op)
                          op: assign_op.Equal
                          rhs: {<list>}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <r>
                  pattern: (pat.Words words:[{<r>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'op='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'op='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'op='> name:op)
                          op: assign_op.Equal
                          rhs: {<remove>}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <Id.Lit_Star '*'>
                  pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.Simple
                      blame_tok: <echo>
                      more_env: []
                      words: [
                        {<echo>}
                        {(DQ <'Usage: '> ($ Id.VSub_DollarName command) <' [-elr] [ file ]'>)}
                      ]
                      redirects: [(Redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                      do_fork: T
                    )
                    (command.ControlFlow
                      keyword: <Id.ControlFlow_Exit exit>
                      arg_word: {<2>}
                    )
                  ]
                  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.Case
      case_kw: <Id.KW_Case case>
      to_match: (case_arg.Word w:{($ Id.VSub_Pound '#')})
      arms_start: <Id.KW_In in>
      arms: [
        (CaseArm
          left: <0>
          pattern: (pat.Words words:[{<0>}])
          middle: <Id.Right_CasePat _>
          action: []
          right: <Id.Op_DSemi _>
        )
        (CaseArm
          left: <1>
          pattern: (pat.Words words:[{<1>}])
          middle: <Id.Right_CasePat _>
          action: [
            (command.Sentence
              child: 
                (command.ShAssignment
                  left: <Id.Lit_VarLike 'replace='>
                  pairs: [
                    (AssignPair
                      left: <Id.Lit_VarLike 'replace='>
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'replace='> name:replace)
                      op: assign_op.Equal
                      rhs: {($ Id.VSub_Number 1)}
                    )
                  ]
                  redirects: []
                )
              terminator: <Id.Op_Semi _>
            )
            (command.Simple
              blame_tok: <shift>
              more_env: []
              words: [{<shift>}]
              redirects: []
              do_fork: T
            )
          ]
          right: <Id.Op_DSemi _>
        )
      ]
      arms_end: <Id.KW_Esac esac>
      redirects: []
    )
    (command.Case
      case_kw: <Id.KW_Case case>
      to_match: (case_arg.Word w:{($ Id.VSub_DollarName op)})
      arms_start: <Id.KW_In in>
      arms: [
        (CaseArm
          left: <Id.Left_SingleQuote '\''>
          pattern: (pat.Words words:[{(SQ )}])
          middle: <Id.Right_CasePat _>
          action: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'op='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'op='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'op='> name:op)
                  op: assign_op.Equal
                  rhs: {<replace>}
                )
              ]
              redirects: []
            )
          ]
          right: <Id.Op_DSemi _>
        )
        (CaseArm
          left: <Id.Lit_Star '*'>
          pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
          middle: <Id.Right_CasePat _>
          action: [
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_DollarName replace)})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <Id.Lit_QMark '?'>
                  pattern: (pat.Words words:[{<Id.Lit_QMark '?'> <Id.Lit_Star '*'>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.Simple
                      blame_tok: <set>
                      more_env: []
                      words: [{<set>} {<-->} {(SQ <'-?'>)}]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
          ]
          right: <Id.Op_DSemi _>
        )
      ]
      arms_end: <Id.KW_Esac esac>
      redirects: []
    )
    (command.Case
      case_kw: <Id.KW_Case case>
      to_match: (case_arg.Word w:{($ Id.VSub_Pound '#')})
      arms_start: <Id.KW_In in>
      arms: [
        (CaseArm
          left: <0>
          pattern: (pat.Words words:[{<0>}])
          middle: <Id.Right_CasePat _>
          action: []
          right: <Id.Op_DSemi _>
        )
        (CaseArm
          left: <Id.Lit_Star '*'>
          pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
          middle: <Id.Right_CasePat _>
          action: [
            (command.Sentence
              child: 
                (command.Simple
                  blame_tok: <getopts>
                  more_env: []
                  words: [{<getopts>} {(DQ ($ Id.VSub_DollarName usage))} {<OPT>}]
                  redirects: []
                  do_fork: T
                )
              terminator: <Id.Op_Semi _>
            )
            (command.ControlFlow keyword:<Id.ControlFlow_Exit exit> arg_word:{<2>})
          ]
          right: <Id.Op_DSemi _>
        )
      ]
      arms_end: <Id.KW_Esac esac>
      redirects: []
    )
    (command.Simple
      blame_tok: <set>
      more_env: []
      words: [{<set>} {<-o>} {<errexit>} {<-o>} {<noglob>}]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <Id.VSub_DollarName '$cron'>
      more_env: []
      words: [{($ Id.VSub_DollarName cron)} {<-a>}]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <umask>
      more_env: []
      words: [{<umask>} {<077>}]
      redirects: []
      do_fork: T
    )
    (command.Case
      case_kw: <Id.KW_Case case>
      to_match: (case_arg.Word w:{($ Id.VSub_DollarName op)})
      arms_start: <Id.KW_In in>
      arms: [
        (CaseArm
          left: <edit>
          pattern: (pat.Words words:[{<edit>}])
          middle: <Id.Right_CasePat _>
          action: [
            (command.Simple
              blame_tok: <trap>
              more_env: []
              words: [
                {<trap>}
                {(DQ <'rm -f \''> ($ Id.VSub_DollarName temp) <'\''>)}
                {<0>}
                {<1>}
                {<2>}
                {<3>}
                {<15>}
              ]
              redirects: []
              do_fork: T
            )
            (command.If
              if_kw: <Id.KW_If if>
              arms: [
                (IfArm
                  keyword: <Id.KW_If if>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Simple
                          blame_tok: <test>
                          more_env: []
                          words: [{<test>} {<-f>} {(DQ ($ Id.VSub_DollarName file))}]
                          redirects: []
                          do_fork: T
                        )
                      ]
                    )
                  then_kw: <Id.KW_Then then>
                  action: [
                    (command.Simple
                      blame_tok: <cat>
                      more_env: []
                      words: [{<cat>} {(DQ ($ Id.VSub_DollarName file))}]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  spids: [623 634]
                )
              ]
              else_kw: <Id.KW_Else else>
              else_action: [
                (command.Simple
                  blame_tok: <print>
                  more_env: []
                  words: [{<print>} {(DQ <'# MIN HOUR DAY/MONTH MONTH DAY/WEEK COMMAND'>)}]
                  redirects: []
                  do_fork: T
                )
              ]
              fi_kw: <Id.KW_Fi fi>
              redirects: [
                (Redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_DollarName temp))}
                )
              ]
            )
            (command.Simple
              blame_tok: <Id.Left_DollarBrace '${'>
              more_env: []
              words: [
                {
                  (BracedVarSub
                    left: <Id.Left_DollarBrace '${'>
                    token: <Id.VSub_Name VISUAL>
                    var_name: VISUAL
                    suffix_op: 
                      (suffix_op.Unary
                        op: <Id.VTest_ColonHyphen _>
                        arg_word: 
                          {
                            (BracedVarSub
                              left: <Id.Left_DollarBrace '${'>
                              token: <Id.VSub_Name EDITOR>
                              var_name: EDITOR
                              suffix_op: (suffix_op.Unary op:<Id.VTest_ColonHyphen _> arg_word:{<vi>})
                              right: <Id.Right_DollarBrace '}'>
                            )
                          }
                      )
                    right: <Id.Right_DollarBrace '}'>
                  )
                }
                {(DQ ($ Id.VSub_DollarName temp))}
              ]
              redirects: []
              do_fork: T
            )
          ]
          right: <Id.Op_DSemi _>
        )
        (CaseArm
          left: <list>
          pattern: (pat.Words words:[{<list>}])
          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: <test>
                          more_env: []
                          words: [{<test>} {<-f>} {(DQ ($ Id.VSub_DollarName file))}]
                          redirects: []
                          do_fork: T
                        )
                      ]
                    )
                  then_kw: <Id.KW_Then then>
                  action: [
                    (command.Simple
                      blame_tok: <cat>
                      more_env: []
                      words: [{<cat>} {(DQ ($ Id.VSub_DollarName file))}]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  spids: [681 692]
                )
              ]
              else_action: []
              fi_kw: <Id.KW_Fi fi>
              redirects: []
            )
            (command.ControlFlow keyword:<Id.ControlFlow_Exit exit>)
          ]
          right: <Id.Op_DSemi _>
        )
        (CaseArm
          left: <remove>
          pattern: (pat.Words words:[{<remove>}])
          middle: <Id.Right_CasePat _>
          action: [
            (command.Simple
              blame_tok: <Id.VSub_DollarName '$cron'>
              more_env: []
              words: [{($ Id.VSub_DollarName cron)} {<-r>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <rm>
              more_env: []
              words: [{<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName file))}]
              redirects: []
              do_fork: T
            )
            (command.ControlFlow keyword:<Id.ControlFlow_Exit exit>)
          ]
          right: <Id.Op_DSemi _>
        )
        (CaseArm
          left: <replace>
          pattern: (pat.Words words:[{<replace>}])
          middle: <Id.Right_CasePat _>
          action: [
            (command.Simple
              blame_tok: <trap>
              more_env: []
              words: [
                {<trap>}
                {(DQ <'rm -f \''> ($ Id.VSub_DollarName temp) <'\''>)}
                {<0>}
                {<1>}
                {<2>}
                {<3>}
                {<15>}
              ]
              redirects: []
              do_fork: T
            )
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_DollarName replace)})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <->
                  pattern: (pat.Words words:[{<->}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'temp='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'temp='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'temp='> name:temp)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName file)}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <Id.Left_DoubleQuote '"'>
                  pattern: (pat.Words words:[{(DQ )}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.Simple
                      blame_tok: <cat>
                      more_env: []
                      words: [{<cat>}]
                      redirects: [
                        (Redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName temp))}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
                (CaseArm
                  left: <Id.Lit_Star '*'>
                  pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.Simple
                      blame_tok: <cat>
                      more_env: []
                      words: [{<cat>} {(DQ ($ Id.VSub_DollarName replace))}]
                      redirects: [
                        (Redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName temp))}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.Simple
              blame_tok: <test>
              more_env: []
              words: [{<test>} {<-s>} {(DQ ($ Id.VSub_DollarName temp))}]
              redirects: []
              do_fork: T
            )
          ]
          right: <Id.Op_DSemi _>
        )
      ]
      arms_end: <Id.KW_Esac esac>
      redirects: []
    )
    (command.Simple
      blame_tok: <exec>
      more_env: []
      words: [{<exec>}]
      redirects: [(Redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<'/dev/null'>})]
      do_fork: T
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: 
        (condition.Shell
          commands: [
            (command.Simple
              blame_tok: <read>
              more_env: []
              words: [{<read>} {<-r>} {<line>}]
              redirects: []
              do_fork: T
            )
          ]
        )
      body: 
        (command.DoGroup
          left: <Id.KW_Do do>
          children: [
            (command.Simple
              blame_tok: <set>
              more_env: []
              words: [{<set>} {(SQ )} {($ Id.VSub_DollarName line)}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <shift>
              more_env: []
              words: [{<shift>}]
              redirects: []
              do_fork: T
            )
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_Number 1)})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <Id.Left_SingleQuote '\''>
                  pattern: (pat.Words words:[{(SQ )} {(SQ <'#'>) <Id.Lit_Star '*'>}])
                  middle: <Id.Right_CasePat _>
                  action: [(command.ControlFlow keyword:<Id.ControlFlow_Continue continue>)]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_Pound '#')})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <Id.Lit_LBracket '['>
                  pattern: (pat.Words words:[{<Id.Lit_LBracket '['> <0-5> <Id.Lit_RBracket ']'>}])
                  middle: <Id.Right_CasePat _>
                  action: [
                    (command.Simple
                      blame_tok: <print>
                      more_env: []
                      words: [
                        {<print>}
                        {<-u2>}
                        {
                          (DQ ($ Id.VSub_DollarName command) <': '> ($ Id.VSub_DollarName line) 
                            <': invalid entry'>
                          )
                        }
                      ]
                      redirects: []
                      do_fork: T
                    )
                  ]
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.Simple
              blame_tok: <Id.VSub_DollarName '$cron'>
              more_env: []
              words: [
                {($ Id.VSub_DollarName cron)}
                {<-n>}
                {<-t>}
                {
                  (DQ <'cron '> ($ Id.VSub_Number 1) <' '> ($ Id.VSub_Number 2) <' '> ($ Id.VSub_Number 3) 
                    <' '> ($ Id.VSub_Number 4) <' '> ($ Id.VSub_Number 5)
                  )
                }
                {<true>}
              ]
              redirects: []
              do_fork: T
            )
          ]
          right: <Id.KW_Done done>
        )
      redirects: [
        (Redir
          op: <Id.Redir_Less '<'>
          loc: (redir_loc.Fd fd:0)
          arg: {(DQ ($ Id.VSub_DollarName temp))}
        )
      ]
    )
    (command.Simple
      blame_tok: <Id.VSub_DollarName '$cron'>
      more_env: []
      words: [{($ Id.VSub_DollarName cron)} {<-r>}]
      redirects: []
      do_fork: T
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: 
        (condition.Shell
          commands: [
            (command.Simple
              blame_tok: <read>
              more_env: []
              words: [{<read>} {<-r>} {<line>}]
              redirects: []
              do_fork: T
            )
          ]
        )
      body: 
        (command.DoGroup
          left: <Id.KW_Do do>
          children: [
            (command.Simple
              blame_tok: <set>
              more_env: []
              words: [{<set>} {(SQ )} {($ Id.VSub_DollarName line)}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <shift>
              more_env: []
              words: [{<shift>}]
              redirects: []
              do_fork: T
            )
            (command.Case
              case_kw: <Id.KW_Case case>
              to_match: (case_arg.Word w:{($ Id.VSub_Number 1)})
              arms_start: <Id.KW_In in>
              arms: [
                (CaseArm
                  left: <Id.Left_SingleQuote '\''>
                  pattern: (pat.Words words:[{(SQ )} {(SQ <'#'>) <Id.Lit_Star '*'>}])
                  middle: <Id.Right_CasePat _>
                  action: [(command.ControlFlow keyword:<Id.ControlFlow_Continue continue>)]
                  right: <Id.Op_DSemi _>
                )
              ]
              arms_end: <Id.KW_Esac esac>
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'time='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'time='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'time='> name:time)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ ($ Id.VSub_Number 1) <' '> ($ Id.VSub_Number 2) <' '> ($ Id.VSub_Number 3) <' '> 
                        ($ Id.VSub_Number 4) <' '> ($ Id.VSub_Number 5)
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <shift>
              more_env: []
              words: [{<shift>} {<5>}]
              redirects: []
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'exec='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'exec='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'exec='> name:exec)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (BracedVarSub
                        left: <Id.Left_DollarBrace '${'>
                        token: <Id.VSub_Star '*'>
                        var_name: '*'
                        suffix_op: 
                          (suffix_op.PatSub
                            pat: 
                              {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\\'> ch:'\\') 
                                <'('> <Id.Lit_Other '?'> <')'>
                              }
                            replace: 
                              {<'\x01'> 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\1'>
                                  ch: 1
                                )
                              }
                            replace_mode: Id.Lit_Slash
                            slash_tok: <Id.VOp2_Slash _>
                          )
                        right: <Id.Right_DollarBrace '}'>
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'exec='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'exec='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'exec='> name:exec)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (BracedVarSub
                        left: <Id.Left_DollarBrace '${'>
                        token: <Id.VSub_Name exec>
                        var_name: exec
                        suffix_op: 
                          (suffix_op.PatSub
                            pat: 
                              {
                                (word_part.ExtGlob
                                  op: <Id.ExtGlob_At '@('>
                                  arms: [{<'['> <Id.Lit_Other '!'> <'\x01]'>}]
                                  right: <Id.Right_ExtGlob _>
                                ) <Id.Lit_Percent '%'>
                              }
                            replace: 
                              {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\1'> ch:1) 
                                <'\n'>
                              }
                            replace_mode: Id.Lit_Slash
                            slash_tok: <Id.VOp2_Slash _>
                          )
                        right: <Id.Right_DollarBrace '}'>
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'exec='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'exec='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'exec='> name:exec)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (BracedVarSub
                        left: <Id.Left_DollarBrace '${'>
                        token: <Id.VSub_Name exec>
                        var_name: exec
                        suffix_op: 
                          (suffix_op.PatSub
                            pat: {<'^A'>}
                            replace: 
                              {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\\'> ch:'\\')}
                            replace_mode: Id.Lit_Slash
                            slash_tok: <Id.VOp2_Slash _>
                          )
                        right: <Id.Right_DollarBrace '}'>
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'exec='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'exec='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'exec='> name:exec)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (BracedVarSub
                        left: <Id.Left_DollarBrace '${'>
                        token: <Id.VSub_Name exec>
                        var_name: exec
                        suffix_op: 
                          (suffix_op.PatSub
                            pat: 
                              {
                                (word_part.ExtGlob
                                  op: <Id.ExtGlob_At '@('>
                                  arms: [{<'\n'> <Id.Lit_Other '*'>}]
                                  right: <Id.Right_ExtGlob _>
                                )
                              }
                            replace: 
                              {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\<'> ch:'<') 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\<'>
                                  ch: '<'
                                ) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\\'> ch:'\\') <'\x01\n'> 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\1'>
                                  ch: 1
                                ) <'\n'> <'\x01'>
                              }
                            replace_mode: Id.Lit_Slash
                            slash_tok: <Id.VOp2_Slash _>
                          )
                        right: <Id.Right_DollarBrace '}'>
                      )
                    }
                )
              ]
              redirects: []
            )
            (command.Simple
              blame_tok: <Id.VSub_DollarName '$cron'>
              more_env: []
              words: [
                {($ Id.VSub_DollarName cron)}
                {<-t>}
                {(DQ <'cron '> ($ Id.VSub_DollarName time))}
                {(DQ ($ Id.VSub_DollarName exec))}
              ]
              redirects: [(Redir op:<Id.Redir_Great '2>'> loc:(redir_loc.Fd fd:2) arg:{<'/dev/null'>})]
              do_fork: T
            )
          ]
          right: <Id.KW_Done done>
        )
      redirects: [
        (Redir
          op: <Id.Redir_Less '<'>
          loc: (redir_loc.Fd fd:0)
          arg: {(DQ ($ Id.VSub_DollarName temp))}
        )
      ]
    )
    (command.Case
      case_kw: <Id.KW_Case case>
      to_match: (case_arg.Word w:{($ Id.VSub_DollarName replace)})
      arms_start: <Id.KW_In in>
      arms: [
        (CaseArm
          left: <->
          pattern: (pat.Words words:[{<->}])
          middle: <Id.Right_CasePat _>
          action: []
          right: <Id.Op_DSemi _>
        )
        (CaseArm
          left: <Id.Lit_Star '*'>
          pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
          middle: <Id.Right_CasePat _>
          action: [
            (command.Simple
              blame_tok: <cp>
              more_env: []
              words: [{<cp>} {(DQ ($ Id.VSub_DollarName temp))} {(DQ ($ Id.VSub_DollarName file))}]
              redirects: []
              do_fork: T
            )
          ]
          right: <Id.Op_DSemi _>
        )
      ]
      arms_end: <Id.KW_Esac esac>
      redirects: []
    )
  ]
)