(command.CommandList
  children: [
    (C {<Id.Lit_Colon ':'>} {<C>} {<language>} {<message>} {<catalog>} {<compiler>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike '__command__='> name:__command__)
          op: assign_op.Equal
          rhs: {<msgcc>}
          spids: [74]
        )
      ]
      redirects: []
    )
    (C {<integer>} {<Id.Lit_VarLike '__similar__='> <30>})
    (command.Case
      to_match: 
        {
          (command_sub
            left_token: <Id.Left_Backtick '`'>
            child: 
              (command.Subshell
                child: 
                  (command.CommandList
                    children: [
                      (command.Sentence
                        child: (C {<getopts>} {(SQ <'[-][123:xyz]'>)} {<opt>} {<--xyz>})
                        terminator: <Id.Op_Semi _>
                      )
                      (C {<echo>} {<0> ($ Id.VSub_DollarName opt)})
                    ]
                  )
                redirects: [
                  (redir
                    op: <Id.Redir_Great '2>'>
                    loc: (redir_loc.Fd fd:2)
                    arg: {<'/dev/null'>}
                  )
                ]
              )
            right: <Id.Backtick_Right '`'>
          )
        }
      arms: [
        (case_arm
          pat_list: [{<0123>}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'ARGV0='> name:ARGV0)
                  op: assign_op.Equal
                  rhs: {(DQ <'-a '> ($ Id.VSub_DollarName __command__))}
                  spids: [115]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'USAGE='> name:USAGE)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (single_quoted
                        left: <Id.Left_DollarSingleQuote '$\''>
                        tokens: [
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals '[-?\n'>
                          <Id.Char_Literals '@(#)$Id: msgcc (AT&T Labs Research) 2002-09-15 $\n'>
                          <Id.Char_Literals ']\n'>
                        ]
                        right: <Id.Right_SingleQuote '\''>
                      ) ($ Id.VSub_DollarName USAGE_LICENSE) 
                      (single_quoted
                        left: <Id.Left_DollarSingleQuote '$\''>
                        tokens: [
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals '[+NAME?msgcc - C language message catalog compiler]\n'>
                          <Id.Char_Literals '[+DESCRIPTION?'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals msgcc>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals 
' is a C language message catalog compiler. It accepts\n'
                          >
                          <Id.Char_Literals '\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals cc>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) style options and arguments. A '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals msgcpp>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals .mso>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' file\n'>
                          <Id.Char_Literals '\tis generated for each input '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals .c>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' file. If the '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -c>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' option is not\n'>
                          <Id.Char_Literals '\tspecified then a '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals gencat>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) format '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals .msg>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' file is generated from\n'>
                          <Id.Char_Literals '\tthe input '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals .mso>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' and '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals .msg>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' files. If '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -c>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' is not specified then\n'>
                          <Id.Char_Literals '\ta '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals .msg>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' suffix is appended to the '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -o>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals file>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ' if it doesn'>
                          <Id.Char_OneChar '\\\''>
                          <Id.Char_Literals 't\n'>
                          <Id.Char_Literals '\talready have a suffix. The default output is '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals a.out.msg>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' if '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -c>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals '\tand '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -o>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' are not specified.]\n'>
                          <Id.Char_Literals '[+?If '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -M-new>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals 
' is not specified then messages are merged with those in the\n'
                          >
                          <Id.Char_Literals '\tpre-existing '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -o>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' file.]\n'>
                          <Id.Char_Literals '[M?Set a '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals msgcc>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' specific '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals option>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals '. '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals option>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ' may be:]:[-option]{\n'>
                          <Id.Char_Literals '\t[+mkmsgs?The '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -o>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' file is assumed to be in '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals mkmsgs>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1) format.]\n'>
                          <Id.Char_Literals '\t[+new?Create a new '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -o>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' file.]\n'>
                          <Id.Char_Literals '\t[+preserve?Messages in the '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -o>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' file that are not in new\n'>
                          <Id.Char_Literals '\t\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals .msg>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' file arguments are preserved. The default is to\n'>
                          <Id.Char_Literals 
'\t\teither reuse the message numbers with new message text that\n'
                          >
                          <Id.Char_Literals 
'\t\tis similar to the old or to delete the message text, leaving\n'
                          >
                          <Id.Char_Literals '\t\tan unused message number.]\n'>
                          <Id.Char_Literals '\t[+set='>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals number>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals '?Set the message set number to '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals number>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals '. The default\n'>
                          <Id.Char_Literals '\t\tis '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals 1>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '.]\n'>
                          <Id.Char_Literals '\t[+similar='>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals number>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals '?The message text similarity measure thresshold.\n'>
                          <Id.Char_Literals '\t\tThe similarity measure between '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals old>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ' and '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals new>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ' message\n'>
                          <Id.Char_Literals '\t\ttext is 100*(2*gzip('>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals old>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals '+'>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals new>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ')/(gzip('>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals old>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ')+gzip('>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals new>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals '))-1),\n'>
                          <Id.Char_Literals '\t\twhere gzip('>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals x>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ') is the size of text '>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals x>
                          <Id.Char_OneChar '\\a'>
                          <Id.Char_Literals ' when compressed by\n'>
                          <Id.Char_Literals '\t\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals gzip>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1). The default threshhold is '>
                        ]
                        right: <Id.Right_SingleQuote '\''>
                      ) ($ Id.VSub_DollarName __similar__) 
                      (single_quoted
                        left: <Id.Left_DollarSingleQuote '$\''>
                        tokens: [
                          <Id.Char_Literals '. A\n'>
                          <Id.Char_Literals '\t\tthreshhold of '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals 0>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' turns off message replacement, but unused\n'>
                          <Id.Char_Literals '\t\told messages are still deleted. Use '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals -M-preserve>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals ' to preserve\n'>
                          <Id.Char_Literals '\t\tall old messages.]\n'>
                          <Id.Char_Literals 
'\t[+verbose?Trace similar message replacements on the standard error.]\n'
                          >
                          <Id.Char_Literals '}\n'>
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals 'file ...\n'>
                          <Id.Char_Literals '\n'>
                          <Id.Char_Literals '[+SEE ALSO?'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals cc>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1), '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals cpp>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1), '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals gencat>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1), '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals msggen>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1),\n'>
                          <Id.Char_Literals '\t'>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals msgcpp>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1), '>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals msgcvt>
                          <Id.Char_OneChar '\\b'>
                          <Id.Char_Literals '(1)]\n'>
                        ]
                        right: <Id.Right_SingleQuote '\''>
                      )
                    }
                  spids: [122]
                )
              ]
              redirects: []
            )
          ]
          spids: [112 113 369 -1]
        )
        (case_arm
          pat_list: [{<Id.Lit_Star '*'>}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'ARGV0='> name:ARGV0)
                  op: assign_op.Equal
                  rhs: {(DQ )}
                  spids: [374]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'USAGE='> name:USAGE)
                  op: assign_op.Equal
                  rhs: {(DQ <'M:[-option] [ cc-options ] file ...'>)}
                  spids: [379]
                )
              ]
              redirects: []
            )
          ]
          spids: [371 372 385 -1]
        )
      ]
      redirects: []
    )
    (command.ShFunction
      name: usage
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'OPTIND='> name:OPTIND)
                  op: assign_op.Equal
                  rhs: {<0>}
                  spids: [397]
                )
              ]
              redirects: []
            )
            (C {<getopts>} {($ Id.VSub_DollarName ARGV0)} {(DQ ($ Id.VSub_DollarName USAGE))} {<OPT>} 
              {(SQ <'-?'>)}
            )
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<2>})
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: keys
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Pipeline
              children: [
                (command.Simple
                  words: [
                    {($ Id.VSub_Number 1)}
                    {<--> <Id.Lit_QMark '?'> <Id.Lit_QMark '?'> <keys>}
                    {<-->}
                  ]
                  redirects: [(redir op:<Id.Redir_GreatAnd '2>&'> loc:(redir_loc.Fd fd:2) arg:{<1>})]
                  more_env: []
                  do_fork: T
                )
                (C {<grep>} {(SQ <'^".*"$'>)})
              ]
              negated: F
              stderr_indices: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (C {<typeset>} {<-A>} {<__index__>})
    (C {<typeset>} {<__keep__>} {<__text__>} {<__drop__>} {<__oz__>} {<__nz__>} {<__z__>} {<__hit__>} 
      {<__hit_i__>}
    )
    (C {<typeset>} {<__compile__>} {<__debug__>} {<__mkmsgs__>} {<__preprocess__>})
    (C {<typeset>} {<Id.Lit_VarLike '__merge__='> <1>} {<__preserve__>} {<__verbose__>})
    (C {<integer>} {<Id.Lit_VarLike '__i__='> <0>} {<Id.Lit_VarLike '__args__='> <0>} 
      {<Id.Lit_VarLike '__code__='> <0>} {<Id.Lit_VarLike '__files__='> <0>} {<Id.Lit_VarLike '__max__='> <0>} {<Id.Lit_VarLike '__num__='> <0>} 
      {<Id.Lit_VarLike '__skip__='> <0>}
    )
    (C {<integer>} {<Id.Lit_VarLike '__set__='> <1>} {<Id.Lit_VarLike '__sources__='> <0>} 
      {<Id.Lit_VarLike '__cmds__='> <0>} {<Id.Lit_VarLike '__ndrop__='> <0>} {<Id.Lit_VarLike '__new__='> <0>} {<Id.Lit_VarLike '__old__='> <0>}
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike '__out__='> name:__out__)
          op: assign_op.Equal
          rhs: {<a.out.msg>}
          spids: [539]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike '__OUT__='> name:__OUT__)
          op: assign_op.Equal
          rhs: (rhs_word.Empty)
          spids: [542]
        )
      ]
      redirects: []
    )
    (command.Case
      to_match: {(DQ <' '> ($ Id.VSub_Star '*') <' '>)}
      arms: [
        (case_arm
          pat_list: [
            {<Id.Lit_Star '*'> (DQ <' --'>) <Id.Lit_Star '*'>}
            {<Id.Lit_Star '*'> (DQ <' -?'>) <Id.Lit_Star '*'>}
          ]
          action: [
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (C {<getopts>} {($ Id.VSub_DollarName ARGV0)} {(DQ ($ Id.VSub_DollarName USAGE))} 
                      {<OPT>}
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {($ Id.VSub_DollarName OPT)}
                      arms: [
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                          spids: [591 592 596 -1]
                        )
                      ]
                      redirects: []
                    )
                  ]
                )
              redirects: []
            )
          ]
          spids: [555 566 605 -1]
        )
      ]
      redirects: []
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: (condition.Shell commands:[(C {<Id.Lit_Colon ':'>})])
      body: 
        (command.DoGroup
          children: [
            (command.Case
              to_match: {($ Id.VSub_Pound '#')}
              arms: [
                (case_arm
                  pat_list: [{<0>}]
                  action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                  spids: [622 623 627 -1]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike '__arg__='> name:__arg__)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 1)}
                  spids: [633]
                )
              ]
              redirects: []
            )
            (command.Case
              to_match: {($ Id.VSub_DollarName __arg__)}
              arms: [
                (case_arm
                  pat_list: [{<-c>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: 
                            (sh_lhs_expr.Name
                              left: <Id.Lit_VarLike '__compile__='>
                              name: __compile__
                            )
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [647]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [644 645 651 -1]
                )
                (case_arm
                  pat_list: [{<-> <Id.Lit_LBracket '['> <DIU> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: 
                            (sh_lhs_expr.IndexedName
                              left: <Id.Lit_ArrayLhsOpen '__argv__['>
                              name: __argv__
                              index: ($ Id.Lit_ArithVarLike __args__)
                            )
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName __arg__)}
                          spids: [660]
                        )
                      ]
                      redirects: []
                    )
                    (command.DParen
                      child: 
                        (arith_expr.UnaryAssign
                          op_id: Id.Node_PostDPlus
                          child: ($ Id.Lit_ArithVarLike __args__)
                        )
                      redirects: []
                    )
                  ]
                  spids: [654 659 677 -1]
                )
                (case_arm
                  pat_list: [{<-E>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: 
                            (sh_lhs_expr.Name
                              left: <Id.Lit_VarLike '__preprocess__='>
                              name: __preprocess__
                            )
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [683]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [680 681 687 -1]
                )
                (case_arm
                  pat_list: [{<-M-debug>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike '__debug__='> name:__debug__)
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [694]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [690 691 698 -1]
                )
                (case_arm
                  pat_list: [{<-M-mkmsgs>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike '__mkmsgs__='> name:__mkmsgs__)
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [705]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [701 702 709 -1]
                )
                (case_arm
                  pat_list: [{<-M-new>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike '__merge__='> name:__merge__)
                          op: assign_op.Equal
                          rhs: (rhs_word.Empty)
                          spids: [715]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [712 713 718 -1]
                )
                (case_arm
                  pat_list: [{<-M-perserve>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: 
                            (sh_lhs_expr.Name
                              left: <Id.Lit_VarLike '__preserve__='>
                              name: __preserve__
                            )
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [725]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [721 722 729 -1]
                )
                (case_arm
                  pat_list: [{<-M-set> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike '__set__='> name:__set__)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<msggen>} {<-s>} 
                                    {
                                      (braced_var_sub
                                        left: <Id.Left_DollarBrace '${'>
                                        token: <Id.VSub_Name __arg__>
                                        var_name: __arg__
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op: <Id.VOp1_Pound '#'>
                                            arg_word: {<Id.Lit_Other '*'> <'='>}
                                          )
                                        right: <Id.Right_DollarBrace '}'>
                                      ) <.1>
                                    }
                                  )
                                right: <Id.Eof_RParen _>
                              )
                            }
                          spids: [738]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [732 735 754 -1]
                )
                (case_arm
                  pat_list: [{<-M-similar> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: 
                            (sh_lhs_expr.Name
                              left: <Id.Lit_VarLike '__similar__='>
                              name: __similar__
                            )
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                left: <Id.Left_DollarBrace '${'>
                                token: <Id.VSub_Name __arg__>
                                var_name: __arg__
                                suffix_op: 
                                  (suffix_op.Unary
                                    op: <Id.VOp1_Pound '#'>
                                    arg_word: {<Id.Lit_Other '*'> <'='>}
                                  )
                                right: <Id.Right_DollarBrace '}'>
                              )
                            }
                          spids: [763]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [757 760 772 -1]
                )
                (case_arm
                  pat_list: [{<-M-verbose>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: 
                            (sh_lhs_expr.Name
                              left: <Id.Lit_VarLike '__verbose__='>
                              name: __verbose__
                            )
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [779]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [775 776 783 -1]
                )
                (case_arm
                  pat_list: [{<-o>}]
                  action: [
                    (command.Case
                      to_match: {($ Id.VSub_Pound '#')}
                      arms: [
                        (case_arm
                          pat_list: [{<1>}]
                          action: [
                            (C {<print>} {<-u2>} 
                              {
                                (double_quoted
                                  left: <Id.Left_DollarDoubleQuote '$"'>
                                  parts: [
                                    ($ Id.VSub_DollarName __command__)
                                    <': output argument expected'>
                                  ]
                                  right: <Id.Right_DoubleQuote '"'>
                                )
                              }
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Exit exit>
                              arg_word: {<1>}
                            )
                          ]
                          spids: [796 797 814 -1]
                        )
                      ]
                      redirects: []
                    )
                    (C {<shift>})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike '__out__='> name:__out__)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                left: <Id.Left_DollarBrace '${'>
                                token: <Id.VSub_Number 1>
                                var_name: 1
                                suffix_op: 
                                  (suffix_op.Unary
                                    op: <Id.VOp1_Percent '%'>
                                    arg_word: {<.> <Id.Lit_Other '*'>}
                                  )
                                right: <Id.Right_DollarBrace '}'>
                              ) <.msg>
                            }
                          spids: [823]
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike '__OUT__='> name:__OUT__)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_Number 1)}
                          spids: [833]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [786 787 837 -1]
                )
                (case_arm
                  pat_list: [
                    {<Id.Lit_LBracket '['> <-> <Id.Lit_Other '+'> <Id.Lit_RBracket ']'> 
                      <Id.Lit_Star '*'>
                    }
                    {<Id.Lit_Star '*'> <.> <Id.Lit_LBracket '['> <aAlLsS> <Id.Lit_RBracket ']'> 
                      <Id.Lit_Star '*'>
                    }
                  ]
                  action: []
                  spids: [840 852 855 -1]
                )
                (case_arm
                  pat_list: [
                    {<Id.Lit_Star '*'> <.> <Id.Lit_LBracket '['> <cCiI> <Id.Lit_RBracket ']'> 
                      <Id.Lit_Star '*'>
                    }
                    {<Id.Lit_Star '*'> <.> <Id.Lit_LBracket '['> <oO> <Id.Lit_RBracket ']'> 
                      <Id.Lit_Star '*'>
                    }
                  ]
                  action: [
                    (command.Case
                      to_match: {($ Id.VSub_DollarName __arg__)}
                      arms: [
                        (case_arm
                          pat_list: [
                            {<Id.Lit_Star '*'> <.> <Id.Lit_LBracket '['> <oO> <Id.Lit_RBracket ']'> 
                              <Id.Lit_Star '*'>
                            }
                          ]
                          action: []
                          spids: [881 887 888 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.IndexedName
                                      left: <Id.Lit_ArrayLhsOpen '__srcv__['>
                                      name: __srcv__
                                      index: ($ Id.Lit_ArithVarLike __files__)
                                    )
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName __arg__)}
                                  spids: [894]
                                )
                              ]
                              redirects: []
                            )
                            (command.DParen
                              child: 
                                (arith_expr.UnaryAssign
                                  op_id: Id.Node_PostDPlus
                                  child: ($ Id.Lit_ArithVarLike __sources__)
                                )
                              redirects: []
                            )
                          ]
                          spids: [891 892 911 -1]
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike '__arg__='> name:__arg__)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                left: <Id.Left_DollarBrace '${'>
                                token: <Id.VSub_Name __arg__>
                                var_name: __arg__
                                suffix_op: 
                                  (suffix_op.Unary
                                    op: <Id.VOp1_DPound '##'>
                                    arg_word: {<Id.Lit_Other '*'> <Id.Lit_Slash '/'>}
                                  )
                                right: <Id.Right_DollarBrace '}'>
                              )
                            }
                          spids: [917]
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike '__arg__='> name:__arg__)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                left: <Id.Left_DollarBrace '${'>
                                token: <Id.VSub_Name __arg__>
                                var_name: __arg__
                                suffix_op: 
                                  (suffix_op.Unary
                                    op: <Id.VOp1_Percent '%'>
                                    arg_word: {<.> <Id.Lit_Other '*'>}
                                  )
                                right: <Id.Right_DollarBrace '}'>
                              ) <.mso>
                            }
                          spids: [926]
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: 
                            (sh_lhs_expr.IndexedName
                              left: <Id.Lit_ArrayLhsOpen '__objv__['>
                              name: __objv__
                              index: ($ Id.Lit_ArithVarLike __files__)
                            )
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName __arg__)}
                          spids: [936]
                        )
                      ]
                      redirects: []
                    )
                    (command.DParen
                      child: 
                        (arith_expr.UnaryAssign
                          op_id: Id.Node_PostDPlus
                          child: ($ Id.Lit_ArithVarLike __files__)
                        )
                      redirects: []
                    )
                  ]
                  spids: [858 871 953 -1]
                )
                (case_arm
                  pat_list: [
                    {<Id.Lit_Star '*'> <.ms> <Id.Lit_LBracket '['> <go> <Id.Lit_RBracket ']'>}
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: 
                            (sh_lhs_expr.IndexedName
                              left: <Id.Lit_ArrayLhsOpen '__objv__['>
                              name: __objv__
                              index: ($ Id.Lit_ArithVarLike __files__)
                            )
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName __arg__)}
                          spids: [964]
                        )
                      ]
                      redirects: []
                    )
                    (command.DParen
                      child: 
                        (arith_expr.UnaryAssign
                          op_id: Id.Node_PostDPlus
                          child: ($ Id.Lit_ArithVarLike __files__)
                        )
                      redirects: []
                    )
                  ]
                  spids: [956 961 981 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: 
                            (sh_lhs_expr.IndexedName
                              left: <Id.Lit_ArrayLhsOpen '__cmdv__['>
                              name: __cmdv__
                              index: ($ Id.Lit_ArithVarLike __cmds__)
                            )
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName __arg__)}
                          spids: [987]
                        )
                      ]
                      redirects: []
                    )
                    (command.DParen
                      child: 
                        (arith_expr.UnaryAssign
                          op_id: Id.Node_PostDPlus
                          child: ($ Id.Lit_ArithVarLike __cmds__)
                        )
                      redirects: []
                    )
                  ]
                  spids: [984 985 1004 -1]
                )
              ]
              redirects: []
            )
            (C {<shift>})
          ]
        )
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: 
            (sh_lhs_expr.IndexedName
              left: <Id.Lit_ArrayLhsOpen '__cmdv__['>
              name: __cmdv__
              index: ($ Id.Lit_ArithVarLike __cmds__)
            )
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                left: <Id.Left_DollarBrace '${'>
                token: <Id.VSub_Name __out__>
                var_name: __out__
                suffix_op: (suffix_op.Unary op:<Id.VOp1_Percent '%'> arg_word:{<.msg>})
                right: <Id.Right_DollarBrace '}'>
              )
            }
          spids: [1014]
        )
      ]
      redirects: []
    )
    (command.DParen
      child: (arith_expr.UnaryAssign op_id:Id.Node_PostDPlus child:($ Id.Lit_ArithVarLike __cmds__))
      redirects: []
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.DBracket
                  expr: 
                    (bool_expr.LogicalAnd
                      left: (bool_expr.WordTest w:{($ Id.VSub_DollarName __OUT__)})
                      right: (bool_expr.WordTest w:{($ Id.VSub_DollarName __compile__)})
                    )
                  redirects: []
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: 
                    (sh_lhs_expr.IndexedName
                      left: <Id.Lit_ArrayLhsOpen '__objv__['>
                      name: __objv__
                      index: {<Id.Lit_Digits 0>}
                    )
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName __OUT__)}
                  spids: [1052]
                )
              ]
              redirects: []
            )
          ]
          spids: [1038 1050]
        )
      ]
      else_action: []
      redirects: []
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [(command.DParen child:($ Id.Lit_ArithVarLike __sources__) redirects:[])]
            )
          action: [
            (command.ForExpr
              init: 
                (arith_expr.BinaryAssign
                  op_id: Id.Arith_Equal
                  left: ($ Id.Lit_ArithVarLike __i__)
                  right: {<Id.Lit_Digits 0>}
                )
              cond: 
                (arith_expr.Binary
                  op_id: Id.Arith_LessEqual
                  left: ($ Id.Lit_ArithVarLike __i__)
                  right: ($ Id.Lit_ArithVarLike __files__)
                )
              update: 
                (arith_expr.UnaryAssign
                  op_id: Id.Node_PostDPlus
                  child: ($ Id.Lit_ArithVarLike __i__)
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.WordTest
                                      w: 
                                        {
                                          (braced_var_sub
                                            left: <Id.Left_DollarBrace '${'>
                                            token: <Id.VSub_Name __srcv__>
                                            var_name: __srcv__
                                            bracket_op: 
                                              (bracket_op.ArrayIndex
                                                expr: ($ Id.Lit_ArithVarLike __i__)
                                              )
                                            right: <Id.Right_DollarBrace '}'>
                                          )
                                        }
                                    )
                                  redirects: []
                                )
                              ]
                            )
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.DParen
                                          child: 
                                            (arith_expr.Binary
                                              op_id: Id.Arith_Great
                                              left: ($ Id.Lit_ArithVarLike __sources__)
                                              right: {<Id.Lit_Digits 1>}
                                            )
                                          redirects: []
                                        )
                                      ]
                                    )
                                  action: [
                                    (C {<print>} 
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            left: <Id.Left_DollarBrace '${'>
                                            token: <Id.VSub_Name __srcv__>
                                            var_name: __srcv__
                                            bracket_op: 
                                              (bracket_op.ArrayIndex
                                                expr: ($ Id.Lit_ArithVarLike __i__)
                                              )
                                            right: <Id.Right_DollarBrace '}'>
                                          ) <':'>
                                        )
                                      }
                                    )
                                  ]
                                  spids: [1112 1126]
                                )
                              ]
                              else_action: []
                              redirects: []
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.WordTest
                                              w: {($ Id.VSub_DollarName __preprocess__)}
                                            )
                                          redirects: []
                                        )
                                      ]
                                    )
                                  action: [
                                    (C {<msgcpp>} 
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            left: <Id.Left_DollarBrace '${'>
                                            token: <Id.VSub_Name __argv__>
                                            var_name: __argv__
                                            bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                            right: <Id.Right_DollarBrace '}'>
                                          )
                                        )
                                      } 
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            left: <Id.Left_DollarBrace '${'>
                                            token: <Id.VSub_Name __srcv__>
                                            var_name: __srcv__
                                            bracket_op: 
                                              (bracket_op.ArrayIndex
                                                expr: ($ Id.Lit_ArithVarLike __i__)
                                              )
                                            right: <Id.Right_DollarBrace '}'>
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  spids: [1144 1153]
                                )
                              ]
                              else_action: [
                                (command.Simple
                                  words: [
                                    {<msgcpp>}
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          left: <Id.Left_DollarBrace '${'>
                                          token: <Id.VSub_Name __argv__>
                                          var_name: __argv__
                                          bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                          right: <Id.Right_DollarBrace '}'>
                                        )
                                      )
                                    }
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          left: <Id.Left_DollarBrace '${'>
                                          token: <Id.VSub_Name __srcv__>
                                          var_name: __srcv__
                                          bracket_op: 
                                            (bracket_op.ArrayIndex
                                              expr: ($ Id.Lit_ArithVarLike __i__)
                                            )
                                          right: <Id.Right_DollarBrace '}'>
                                        )
                                      )
                                    }
                                  ]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_Great '>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: 
                                        {
                                          (DQ 
                                            (braced_var_sub
                                              left: <Id.Left_DollarBrace '${'>
                                              token: <Id.VSub_Name __objv__>
                                              var_name: __objv__
                                              bracket_op: 
                                                (bracket_op.ArrayIndex
                                                  expr: ($ Id.Lit_ArithVarLike __i__)
                                                )
                                              right: <Id.Right_DollarBrace '}'>
                                            )
                                          )
                                        }
                                    )
                                  ]
                                  more_env: []
                                  do_fork: T
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [1096 1110]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                  ]
                )
              redirects: []
            )
          ]
          spids: [1062 1071]
        )
      ]
      else_action: []
      redirects: []
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.DBracket
                  expr: 
                    (bool_expr.LogicalAnd
                      left: 
                        (bool_expr.LogicalNot
                          child: (bool_expr.WordTest w:{($ Id.VSub_DollarName __compile__)})
                        )
                      right: 
                        (bool_expr.LogicalNot
                          child: (bool_expr.WordTest w:{($ Id.VSub_DollarName __preprocess__)})
                        )
                    )
                  redirects: []
                )
              ]
            )
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.DBracket
                          expr: 
                            (bool_expr.LogicalAnd
                              left: (bool_expr.WordTest w:{($ Id.VSub_DollarName __merge__)})
                              right: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_r
                                  child: {($ Id.VSub_DollarName __out__)}
                                )
                            )
                          redirects: []
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike '__tmp__='> name:__tmp__)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName __out__) <.tmp>}
                          spids: [1260]
                        )
                      ]
                      redirects: []
                    )
                    (C {<trap>} {(SQ <'__code__=$?; rm -f ${__tmp__}*; exit $__code__'>)} {<0>} {<1>} 
                      {<2>}
                    )
                    (command.WhileUntil
                      keyword: <Id.KW_While while>
                      cond: (condition.Shell commands:[(C {<read>} {<-r>} {<__line__>})])
                      body: 
                        (command.DoGroup
                          children: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.DParen
                                          child: {($ Id.VSub_DollarName __skip__)}
                                          redirects: []
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_GlobDEqual
                                                      left: {($ Id.VSub_DollarName __line__)}
                                                      right: {(SQ <'%}'>) <Id.Lit_Other '*'>}
                                                    )
                                                  redirects: []
                                                )
                                              ]
                                            )
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: 
                                                    (sh_lhs_expr.Name
                                                      left: <Id.Lit_VarLike '__skip__='>
                                                      name: __skip__
                                                    )
                                                  op: assign_op.Equal
                                                  rhs: {<0>}
                                                  spids: [1319]
                                                )
                                              ]
                                              redirects: []
                                            )
                                          ]
                                          spids: [1301 1317]
                                        )
                                      ]
                                      else_action: []
                                      redirects: []
                                    )
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [1289 1299]
                                )
                              ]
                              else_action: []
                              redirects: []
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.LogicalAnd
                                              left: 
                                                (bool_expr.WordTest
                                                  w: {($ Id.VSub_DollarName __mkmsgs__)}
                                                )
                                              right: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_GlobDEqual
                                                  left: {($ Id.VSub_DollarName __line__)}
                                                  right: {(SQ <'%{'>) <Id.Lit_Other '*'>}
                                                )
                                            )
                                          redirects: []
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike '__skip__='>
                                              name: __skip__
                                            )
                                          op: assign_op.Equal
                                          rhs: {<1>}
                                          spids: [1354]
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [1332 1352]
                                )
                              ]
                              else_action: []
                              redirects: []
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.WordTest
                                              w: {($ Id.VSub_DollarName __mkmsgs__)}
                                            )
                                          redirects: []
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_GlobDEqual
                                                      left: {($ Id.VSub_DollarName __line__)}
                                                      right: 
                                                        {(SQ <'%#'>) <Id.Lit_Other '*'> (SQ <';;'>) 
                                                          <Id.Lit_Other '*'>
                                                        }
                                                    )
                                                  redirects: []
                                                )
                                              ]
                                            )
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: 
                                                    (sh_lhs_expr.Name
                                                      left: <Id.Lit_VarLike '__line__='>
                                                      name: __line__
                                                    )
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (braced_var_sub
                                                        left: <Id.Left_DollarBrace '${'>
                                                        token: <Id.VSub_Name __line__>
                                                        var_name: __line__
                                                        suffix_op: 
                                                          (suffix_op.Unary
                                                            op: <Id.VOp1_Pound '#'>
                                                            arg_word: {(SQ <'%#'>)}
                                                          )
                                                        right: <Id.Right_DollarBrace '}'>
                                                      )
                                                    }
                                                  spids: [1397]
                                                )
                                              ]
                                              redirects: []
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: 
                                                    (sh_lhs_expr.Name
                                                      left: <Id.Lit_VarLike '__num__='>
                                                      name: __num__
                                                    )
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (braced_var_sub
                                                        left: <Id.Left_DollarBrace '${'>
                                                        token: <Id.VSub_Name __line__>
                                                        var_name: __line__
                                                        suffix_op: 
                                                          (suffix_op.Unary
                                                            op: <Id.VOp1_Percent '%'>
                                                            arg_word: {(SQ <';;'>) <Id.Lit_Other '*'>}
                                                          )
                                                        right: <Id.Right_DollarBrace '}'>
                                                      )
                                                    }
                                                  spids: [1407]
                                                )
                                              ]
                                              redirects: []
                                            )
                                            (C {<read>} {<-r>} {<__line__>})
                                          ]
                                          spids: [1375 1395]
                                        )
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_GlobDEqual
                                                      left: {($ Id.VSub_DollarName __line__)}
                                                      right: {<Id.Lit_Other '%'> <Id.Lit_Other '*'>}
                                                    )
                                                  redirects: []
                                                )
                                              ]
                                            )
                                          action: [
                                            (command.ControlFlow
                                              token: <Id.ControlFlow_Continue continue>
                                            )
                                          ]
                                          spids: [1425 1439]
                                        )
                                      ]
                                      else_action: [
                                        (C {<print>} {<-u2>} 
                                          {
                                            (double_quoted
                                              left: <Id.Left_DollarDoubleQuote '$"'>
                                              parts: [
                                                ($ Id.VSub_DollarName __command__)
                                                <': unrecognized line='>
                                                ($ Id.VSub_DollarName __line__)
                                              ]
                                              right: <Id.Right_DoubleQuote '"'>
                                            )
                                          }
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: 
                                                (sh_lhs_expr.Name
                                                  left: <Id.Lit_VarLike '__code__='>
                                                  name: __code__
                                                )
                                              op: assign_op.Equal
                                              rhs: {<1>}
                                              spids: [1457]
                                            )
                                          ]
                                          redirects: []
                                        )
                                      ]
                                      redirects: []
                                    )
                                  ]
                                  spids: [1364 1373]
                                )
                              ]
                              else_action: [
                                (command.Case
                                  to_match: {($ Id.VSub_DollarName __line__)}
                                  arms: [
                                    (case_arm
                                      pat_list: [
                                        {
                                          (word_part.ExtGlob
                                            op: <Id.ExtGlob_Plus '+('>
                                            arms: [{<'[0-9]'>}]
                                          ) (SQ <' '>) <Id.Lit_Star '*'>
                                        }
                                      ]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: 
                                                (sh_lhs_expr.Name
                                                  left: <Id.Lit_VarLike '__num__='>
                                                  name: __num__
                                                )
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (braced_var_sub
                                                    left: <Id.Left_DollarBrace '${'>
                                                    token: <Id.VSub_Name __line__>
                                                    var_name: __line__
                                                    suffix_op: 
                                                      (suffix_op.Unary
                                                        op: <Id.VOp1_DPercent '%%'>
                                                        arg_word: {(SQ <' '>) <Id.Lit_Other '*'>}
                                                      )
                                                    right: <Id.Right_DollarBrace '}'>
                                                  )
                                                }
                                              spids: [1483]
                                            )
                                          ]
                                          redirects: []
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: 
                                                (sh_lhs_expr.Name
                                                  left: <Id.Lit_VarLike '__line__='>
                                                  name: __line__
                                                )
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (braced_var_sub
                                                    left: <Id.Left_DollarBrace '${'>
                                                    token: <Id.VSub_Name __line__>
                                                    var_name: __line__
                                                    suffix_op: 
                                                      (suffix_op.Unary
                                                        op: <Id.VOp1_Pound '#'>
                                                        arg_word: {<Id.Lit_Other '*'> (SQ <'"'>)}
                                                      )
                                                    right: <Id.Right_DollarBrace '}'>
                                                  )
                                                }
                                              spids: [1494]
                                            )
                                          ]
                                          redirects: []
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: 
                                                (sh_lhs_expr.Name
                                                  left: <Id.Lit_VarLike '__line__='>
                                                  name: __line__
                                                )
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (braced_var_sub
                                                    left: <Id.Left_DollarBrace '${'>
                                                    token: <Id.VSub_Name __line__>
                                                    var_name: __line__
                                                    suffix_op: 
                                                      (suffix_op.Unary
                                                        op: <Id.VOp1_Percent '%'>
                                                        arg_word: {(SQ <'"'>)}
                                                      )
                                                    right: <Id.Right_DollarBrace '}'>
                                                  )
                                                }
                                              spids: [1505]
                                            )
                                          ]
                                          redirects: []
                                        )
                                      ]
                                      spids: [1473 1480 1515 -1]
                                    )
                                    (case_arm
                                      pat_list: [{<Id.Lit_Star '*'>}]
                                      action: [
                                        (command.ControlFlow
                                          token: <Id.ControlFlow_Continue continue>
                                        )
                                      ]
                                      spids: [1518 1519 1524 -1]
                                    )
                                  ]
                                  redirects: []
                                )
                              ]
                              redirects: []
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.IndexedName
                                      left: <Id.Lit_ArrayLhsOpen '__index__['>
                                      name: __index__
                                      index: {(DQ ($ Id.VSub_DollarName __line__))}
                                    )
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName __num__)}
                                  spids: [1533]
                                )
                              ]
                              redirects: []
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.IndexedName
                                      left: <Id.Lit_ArrayLhsOpen '__text__['>
                                      name: __text__
                                      index: {($ Id.VSub_DollarName __num__)}
                                    )
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName __line__)}
                                  spids: [1545]
                                )
                              ]
                              redirects: []
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.DParen
                                          child: 
                                            (arith_expr.Binary
                                              op_id: Id.Arith_Less
                                              left: ($ Id.Lit_ArithVarLike __max__)
                                              right: ($ Id.Lit_ArithVarLike __num__)
                                            )
                                          redirects: []
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.DParen
                                      child: 
                                        (arith_expr.BinaryAssign
                                          op_id: Id.Arith_Equal
                                          left: ($ Id.Lit_ArithVarLike __max__)
                                          right: ($ Id.Lit_ArithVarLike __num__)
                                        )
                                      redirects: []
                                    )
                                  ]
                                  spids: [1553 1567]
                                )
                              ]
                              else_action: []
                              redirects: []
                            )
                          ]
                        )
                      redirects: [
                        (redir
                          op: <Id.Redir_Less '<'>
                          loc: (redir_loc.Fd fd:0)
                          arg: {($ Id.VSub_DollarName __out__)}
                        )
                      ]
                    )
                    (command.DParen
                      child: 
                        (arith_expr.BinaryAssign
                          op_id: Id.Arith_Equal
                          left: ($ Id.Lit_ArithVarLike __new__)
                          right: 
                            (arith_expr.Binary
                              op_id: Id.Arith_Plus
                              left: ($ Id.Lit_ArithVarLike __max__)
                              right: {<Id.Lit_Digits 1>}
                            )
                        )
                      redirects: []
                    )
                  ]
                  spids: [1243 1258]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike '__tmp__='> name:__tmp__)
                      op: assign_op.Equal
                      rhs: {($ Id.VSub_DollarName __out__)}
                      spids: [1603]
                    )
                  ]
                  redirects: []
                )
                (command.DParen
                  child: 
                    (arith_expr.BinaryAssign
                      op_id: Id.Arith_Equal
                      left: ($ Id.Lit_ArithVarLike __new__)
                      right: {<Id.Lit_Digits 1>}
                    )
                  redirects: []
                )
              ]
              redirects: []
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(command.DParen child:($ Id.Lit_ArithVarLike __code__) redirects:[])]
                    )
                  action: [
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {($ Id.VSub_DollarName __code__)}
                    )
                  ]
                  spids: [1620 1630]
                )
              ]
              else_action: []
              redirects: []
            )
            (command.Simple
              words: [{<exec>}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '1>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {($ Id.VSub_DollarName __tmp__)}
                )
                (redir op:<Id.Redir_GreatAnd '9>&'> loc:(redir_loc.Fd fd:9) arg:{<1>})
              ]
              more_env: []
              do_fork: T
            )
            (C {<print>} {<-r>} {<-->} 
              {(SQ <'$'>) 
                (DQ <' '> 
                  (braced_var_sub
                    left: <Id.Left_DollarBrace '${'>
                    token: <Id.VSub_Name __out__>
                    var_name: __out__
                    suffix_op: (suffix_op.Unary op:<Id.VOp1_Percent '%'> arg_word:{<.msg>})
                    right: <Id.Right_DollarBrace '}'>
                  ) <' message catalog'>
                )
              }
            )
            (C {<print>} {<-r>} {<-->} 
              {(SQ <'$translation'>) 
                (DQ <' '> ($ Id.VSub_DollarName __command__) <' '> 
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (C {<date>} 
                        {<Id.Lit_Other '+'> <Id.Lit_Other '%'> <Y-> <Id.Lit_Other '%'> <m-> 
                          <Id.Lit_Other '%'> <d>
                        }
                      )
                    right: <Id.Eof_RParen _>
                  )
                )
              }
            )
            (C {<print>} {<-r>} {<-->} {(SQ <'$set'>) (DQ <' '> ($ Id.VSub_DollarName __set__))})
            (C {<print>} {<-r>} {<-->} {(SQ <'$quote "'>)})
            (command.Pipeline
              children: [
                (C {<sort>} {<-u>} 
                  {
                    (DQ 
                      (braced_var_sub
                        left: <Id.Left_DollarBrace '${'>
                        token: <Id.VSub_Name __objv__>
                        var_name: __objv__
                        bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                        right: <Id.Right_DollarBrace '}'>
                      )
                    )
                  }
                )
                (BraceGroup
                  left: <Id.Lit_LBrace '{'>
                  children: [
                    (command.WhileUntil
                      keyword: <Id.KW_While while>
                      cond: (condition.Shell commands:[(C {<read>} {<-r>} {<__line__>})])
                      body: 
                        (command.DoGroup
                          children: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike '__op__='> name:__op__)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (braced_var_sub
                                        left: <Id.Left_DollarBrace '${'>
                                        token: <Id.VSub_Name __line__>
                                        var_name: __line__
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op: <Id.VOp1_DPercent '%%'>
                                            arg_word: {<' '> <Id.Lit_Other '*'>}
                                          )
                                        right: <Id.Right_DollarBrace '}'>
                                      )
                                    }
                                  spids: [1751]
                                )
                              ]
                              redirects: []
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike '__line__='>
                                      name: __line__
                                    )
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (braced_var_sub
                                        left: <Id.Left_DollarBrace '${'>
                                        token: <Id.VSub_Name __line__>
                                        var_name: __line__
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op: <Id.VOp1_Pound '#'>
                                            arg_word: {<Id.Lit_Other '*'> <' '>}
                                          )
                                        right: <Id.Right_DollarBrace '}'>
                                      )
                                    }
                                  spids: [1760]
                                )
                              ]
                              redirects: []
                            )
                            (command.Case
                              to_match: {($ Id.VSub_DollarName __op__)}
                              arms: [
                                (case_arm
                                  pat_list: [{<cmd>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike '__a1__='>
                                              name: __a1__
                                            )
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (braced_var_sub
                                                left: <Id.Left_DollarBrace '${'>
                                                token: <Id.VSub_Name __line__>
                                                var_name: __line__
                                                suffix_op: 
                                                  (suffix_op.Unary
                                                    op: <Id.VOp1_DPercent '%%'>
                                                    arg_word: {<' '> <Id.Lit_Other '*'>}
                                                  )
                                                right: <Id.Right_DollarBrace '}'>
                                              )
                                            }
                                          spids: [1779]
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.Case
                                      to_match: {($ Id.VSub_DollarName __a1__)}
                                      arms: [
                                        (case_arm
                                          pat_list: [{<dot_cmd>}]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: 
                                                    (sh_lhs_expr.Name
                                                      left: <Id.Lit_VarLike '__a1__='>
                                                      name: __a1__
                                                    )
                                                  op: assign_op.Equal
                                                  rhs: {<.>}
                                                  spids: [1798]
                                                )
                                              ]
                                              redirects: []
                                            )
                                          ]
                                          spids: [1795 1796 1801 -1]
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (C {<keys>} {($ Id.VSub_DollarName __a1__)})
                                  ]
                                  spids: [1776 1777 1812 -1]
                                )
                                (case_arm
                                  pat_list: [{<def>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike '__a1__='>
                                              name: __a1__
                                            )
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (braced_var_sub
                                                left: <Id.Left_DollarBrace '${'>
                                                token: <Id.VSub_Name __line__>
                                                var_name: __line__
                                                suffix_op: 
                                                  (suffix_op.Unary
                                                    op: <Id.VOp1_DPercent '%%'>
                                                    arg_word: {<' '> <Id.Lit_Other '*'>}
                                                  )
                                                right: <Id.Right_DollarBrace '}'>
                                              )
                                            }
                                          spids: [1818]
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike '__a2__='>
                                              name: __a2__
                                            )
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (braced_var_sub
                                                left: <Id.Left_DollarBrace '${'>
                                                token: <Id.VSub_Name __line__>
                                                var_name: __line__
                                                suffix_op: 
                                                  (suffix_op.Unary
                                                    op: <Id.VOp1_Pound '#'>
                                                    arg_word: {<Id.Lit_Other '*'> <' '>}
                                                  )
                                                right: <Id.Right_DollarBrace '}'>
                                              )
                                            }
                                          spids: [1827]
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (C {<eval>} 
                                      {($ Id.VSub_DollarName __a1__) <Id.Lit_Equals '='> (SQ <'$'>) 
                                        <__a2__>
                                      }
                                    )
                                  ]
                                  spids: [1815 1816 1846 -1]
                                )
                                (case_arm
                                  pat_list: [{<str>}]
                                  action: [
                                    (C {<print>} {<-r>} {<-->} {(DQ ($ Id.VSub_DollarName __line__))})
                                  ]
                                  spids: [1849 1850 1863 -1]
                                )
                                (case_arm
                                  pat_list: [{<Id.KW_Var var>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike '__a1__='>
                                              name: __a1__
                                            )
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (braced_var_sub
                                                left: <Id.Left_DollarBrace '${'>
                                                token: <Id.VSub_Name __line__>
                                                var_name: __line__
                                                suffix_op: 
                                                  (suffix_op.Unary
                                                    op: <Id.VOp1_DPercent '%%'>
                                                    arg_word: {<' '> <Id.Lit_Other '*'>}
                                                  )
                                                right: <Id.Right_DollarBrace '}'>
                                              )
                                            }
                                          spids: [1869]
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike '__a2__='>
                                              name: __a2__
                                            )
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (braced_var_sub
                                                left: <Id.Left_DollarBrace '${'>
                                                token: <Id.VSub_Name __line__>
                                                var_name: __line__
                                                suffix_op: 
                                                  (suffix_op.Unary
                                                    op: <Id.VOp1_Pound '#'>
                                                    arg_word: {<Id.Lit_Other '*'> <' '>}
                                                  )
                                                right: <Id.Right_DollarBrace '}'>
                                              )
                                            }
                                          spids: [1878]
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.Case
                                      to_match: {($ Id.VSub_DollarName __a1__)}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {<Id.KW_DLeftBracket '[['> <Id.Lit_Colon ':'> <digit> 
                                              <Id.Lit_Colon ':'> <Id.Lit_RBracket ']'> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>
                                            }
                                          ]
                                          action: [
                                            (C {<eval>} 
                                              {<Id.Lit_VarLike '__v__='> (SQ <'$'>) 
                                                ($ Id.VSub_DollarName __a2__)
                                              }
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: 
                                                    (sh_lhs_expr.Name
                                                      left: <Id.Lit_VarLike '__v__='>
                                                      name: __v__
                                                    )
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {(SQ <'"'>) 
                                                      (braced_var_sub
                                                        left: <Id.Left_DollarBrace '${'>
                                                        token: <Id.VSub_Name __v__>
                                                        var_name: __v__
                                                        suffix_op: 
                                                          (suffix_op.Slice
                                                            begin: 
                                                              (arith_expr.Binary
                                                                op_id: Id.Arith_Plus
                                                                left: ($ Id.Lit_ArithVarLike __a1__)
                                                                right: {<Id.Lit_Digits 1>}
                                                              )
                                                          )
                                                        right: <Id.Arith_RBrace _>
                                                      )
                                                    }
                                                  spids: [1913]
                                                )
                                              ]
                                              redirects: []
                                            )
                                          ]
                                          spids: [1894 1901 1926 -1]
                                        )
                                        (case_arm
                                          pat_list: [{<Id.Lit_Star '*'>}]
                                          action: [
                                            (C {<eval>} 
                                              {<Id.Lit_VarLike '__v__='> (SQ <'$'>) 
                                                ($ Id.VSub_DollarName __a1__)
                                              }
                                            )
                                          ]
                                          spids: [1929 1930 1941 -1]
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_GlobDEqual
                                                      left: {($ Id.VSub_DollarName __v__)}
                                                      right: {(SQ <'"'>) <Id.Lit_Other '*'> (SQ <'"'>)}
                                                    )
                                                  redirects: []
                                                )
                                              ]
                                            )
                                          action: [
                                            (C {<print>} {<-r>} {<-->} {(DQ ($ Id.VSub_DollarName __v__))})
                                          ]
                                          spids: [1947 1966]
                                        )
                                      ]
                                      else_action: []
                                      redirects: []
                                    )
                                  ]
                                  spids: [1866 1867 1982 -1]
                                )
                                (case_arm
                                  pat_list: [
                                    {<Id.KW_DLeftBracket '[['> <Id.Lit_Colon ':'> <digit> 
                                      <Id.Lit_Colon ':'> <Id.Lit_RBracket ']'> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>
                                    }
                                  ]
                                  action: [
                                    (command.AndOr
                                      ops: [Id.Op_DAmp]
                                      children: [
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.WordTest
                                              w: {($ Id.VSub_DollarName __preserve__)}
                                            )
                                          redirects: []
                                        )
                                        (C {<print>} {<-r>} {<-->} {(DQ ($ Id.VSub_DollarName __line__))})
                                      ]
                                    )
                                  ]
                                  spids: [1985 1992 2014 -1]
                                )
                                (case_arm
                                  pat_list: [{(SQ <'$'>)}]
                                  action: [
                                    (C {<print>} {<-r>} {<-u9>} {($ Id.VSub_DollarName __op__)} 
                                      {<include>} {($ Id.VSub_DollarName __line__)}
                                    )
                                  ]
                                  spids: [2017 2020 2035 -1]
                                )
                              ]
                              redirects: []
                            )
                          ]
                        )
                      redirects: []
                    )
                    (command.ForExpr
                      init: 
                        (arith_expr.BinaryAssign
                          op_id: Id.Arith_Equal
                          left: ($ Id.Lit_ArithVarLike __i__)
                          right: {<Id.Lit_Digits 0>}
                        )
                      cond: 
                        (arith_expr.Binary
                          op_id: Id.Arith_Less
                          left: ($ Id.Lit_ArithVarLike __i__)
                          right: ($ Id.Lit_ArithVarLike __cmds__)
                        )
                      update: 
                        (arith_expr.UnaryAssign
                          op_id: Id.Node_PostDPlus
                          child: ($ Id.Lit_ArithVarLike __i__)
                        )
                      body: 
                        (command.DoGroup
                          children: [
                            (C {<keys>} 
                              {
                                (braced_var_sub
                                  left: <Id.Left_DollarBrace '${'>
                                  token: <Id.VSub_Name __cmdv__>
                                  var_name: __cmdv__
                                  bracket_op: 
                                    (bracket_op.ArrayIndex
                                      expr: ($ Id.Lit_ArithVarLike __i__)
                                    )
                                  right: <Id.Right_DollarBrace '}'>
                                )
                              }
                            )
                          ]
                        )
                      redirects: []
                    )
                  ]
                  redirects: []
                  right: <Id.Lit_RBrace '}'>
                )
                (BraceGroup
                  left: <Id.Lit_LBrace '{'>
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike '__num__='> name:__num__)
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [2089]
                        )
                      ]
                      redirects: []
                    )
                    (command.WhileUntil
                      keyword: <Id.KW_While while>
                      cond: (condition.Shell commands:[(C {<read>} {<-r>} {<__line__>})])
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Case
                              to_match: {($ Id.VSub_DollarName __line__)}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(SQ <'$'>) <Id.Lit_LBracket '['> 
                                      (word_part.EscapedLiteral
                                        token: <Id.Lit_EscapedChar '\\ '>
                                        ch: ' '
                                      ) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\t'> ch:'\t') <Id.Lit_RBracket ']'> 
                                      <Id.Lit_Star '*'>
                                    }
                                  ]
                                  action: [
                                    (C {<print>} {<-r>} {<-->} {(DQ ($ Id.VSub_DollarName __line__))})
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [2111 2119 2136 -1]
                                )
                                (case_arm
                                  pat_list: [
                                    {(SQ <'$'>) <Id.Lit_Star '*'>}
                                    {<Id.Lit_Star '*'> (DQ <'@(#)'>) <Id.Lit_Star '*'>}
                                    {<Id.Lit_Star '*'> (DQ <'<'>) 
                                      (word_part.ExtGlob
                                        op: <Id.ExtGlob_Star '*('>
                                        arms: [{<'[[:word:] .-]'>}]
                                      ) (DQ <'@'>) (word_part.ExtGlob op:<Id.ExtGlob_Star '*('> arms:[{<'[[:word:] .-]'>}]) (DQ <'>'>) 
                                      (word_part.ExtGlob
                                        op: <Id.ExtGlob_Star '*('>
                                        arms: [{<'[ \t]'>}]
                                      ) (SQ <'"'>)
                                    }
                                    {(DQ <'http://'>) <Id.Lit_Star '*'>}
                                  ]
                                  action: [
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [2139 2177 2183 -1]
                                )
                                (case_arm
                                  pat_list: [
                                    {<Id.Lit_Star '*'> <Id.KW_DLeftBracket '[['> <Id.Lit_Colon ':'> 
                                      <alpha> <Id.Lit_Colon ':'> <Id.Lit_RBracket ']'> <Id.Lit_RBracket ']'> <Id.KW_DLeftBracket '[['> 
                                      <Id.Lit_Colon ':'> <alpha> <Id.Lit_Colon ':'> <Id.Lit_RBracket ']'> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>
                                    }
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike '__line__='>
                                              name: __line__
                                            )
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (braced_var_sub
                                                left: <Id.Left_DollarBrace '${'>
                                                token: <Id.VSub_Name __line__>
                                                var_name: __line__
                                                suffix_op: 
                                                  (suffix_op.Unary
                                                    op: <Id.VOp1_Pound '#'>
                                                    arg_word: {<Id.Lit_Other '*'> (SQ <'"'>)}
                                                  )
                                                right: <Id.Right_DollarBrace '}'>
                                              )
                                            }
                                          spids: [2203]
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike '__line__='>
                                              name: __line__
                                            )
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (braced_var_sub
                                                left: <Id.Left_DollarBrace '${'>
                                                token: <Id.VSub_Name __line__>
                                                var_name: __line__
                                                suffix_op: 
                                                  (suffix_op.Unary
                                                    op: <Id.VOp1_Percent '%'>
                                                    arg_word: {(SQ <'"'>)}
                                                  )
                                                right: <Id.Right_DollarBrace '}'>
                                              )
                                            }
                                          spids: [2214]
                                        )
                                      ]
                                      redirects: []
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.WordTest
                                                      w: {($ Id.VSub_DollarName __line__)}
                                                    )
                                                  redirects: []
                                                )
                                              ]
                                            )
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: 
                                                    (condition.Shell
                                                      commands: [
                                                        (command.DBracket
                                                          expr: 
                                                            (bool_expr.WordTest
                                                              w: 
                                                                {
                                                                  (braced_var_sub
                                                                    left: <Id.Left_DollarBrace '${'>
                                                                    token: <Id.VSub_Name __index__>
                                                                    var_name: __index__
                                                                    bracket_op: 
                                                                      (bracket_op.ArrayIndex
                                                                        expr: 
                                                                          {
                                                                            (DQ 
                                                                              ($ Id.VSub_DollarName 
__line__
                                                                              )
                                                                            )
                                                                          }
                                                                      )
                                                                    right: <Id.Right_DollarBrace '}'>
                                                                  )
                                                                }
                                                            )
                                                          redirects: []
                                                        )
                                                      ]
                                                    )
                                                  action: [
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: 
                                                            (condition.Shell
                                                              commands: [
                                                                (command.DBracket
                                                                  expr: 
                                                                    (bool_expr.LogicalNot
                                                                      child: 
                                                                        (bool_expr.WordTest
                                                                          w: 
                                                                            {
                                                                              ($ Id.VSub_DollarName 
__preserve__
                                                                              )
                                                                            }
                                                                        )
                                                                    )
                                                                  redirects: []
                                                                )
                                                              ]
                                                            )
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      left: 
                                                                        <Id.Lit_VarLike '__num__='>
                                                                      name: __num__
                                                                    )
                                                                  op: assign_op.Equal
                                                                  rhs: 
                                                                    {
                                                                      (braced_var_sub
                                                                        left: 
                                                                          <Id.Left_DollarBrace '${'>
                                                                        token: 
                                                                          <Id.VSub_Name __index__>
                                                                        var_name: __index__
                                                                        bracket_op: 
                                                                          (bracket_op.ArrayIndex
                                                                            expr: 
                                                                              {
                                                                                (DQ 
                                                                                  ($ 
Id.VSub_DollarName __line__
                                                                                  )
                                                                                )
                                                                              }
                                                                          )
                                                                        right: 
                                                                          <Id.Right_DollarBrace '}'>
                                                                      )
                                                                    }
                                                                  spids: [2266]
                                                                )
                                                              ]
                                                              redirects: []
                                                            )
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.IndexedName
                                                                      left: 
                                                                        <Id.Lit_ArrayLhsOpen 
'__keep__['
                                                                        >
                                                                      name: __keep__
                                                                      index: 
                                                                        {
                                                                          ($ Id.VSub_DollarName 
__num__
                                                                          )
                                                                        }
                                                                    )
                                                                  op: assign_op.Equal
                                                                  rhs: {<1>}
                                                                  spids: [2277]
                                                                )
                                                              ]
                                                              redirects: []
                                                            )
                                                          ]
                                                          spids: [2253 2264]
                                                        )
                                                      ]
                                                      else_action: []
                                                      redirects: []
                                                    )
                                                  ]
                                                  spids: [2235 2251]
                                                )
                                              ]
                                              else_action: [
                                                (command.WhileUntil
                                                  keyword: <Id.KW_While while>
                                                  cond: 
                                                    (condition.Shell
                                                      commands: [
                                                        (command.DBracket
                                                          expr: 
                                                            (bool_expr.WordTest
                                                              w: 
                                                                {
                                                                  (braced_var_sub
                                                                    left: <Id.Left_DollarBrace '${'>
                                                                    token: <Id.VSub_Name __text__>
                                                                    var_name: __text__
                                                                    bracket_op: 
                                                                      (bracket_op.ArrayIndex
                                                                        expr: 
                                                                          {
                                                                            ($ Id.VSub_DollarName 
__num__
                                                                            )
                                                                          }
                                                                      )
                                                                    right: <Id.Right_DollarBrace '}'>
                                                                  )
                                                                }
                                                            )
                                                          redirects: []
                                                        )
                                                      ]
                                                    )
                                                  body: 
                                                    (command.DoGroup
                                                      children: [
                                                        (command.DParen
                                                          child: 
                                                            (arith_expr.UnaryAssign
                                                              op_id: Id.Node_PostDPlus
                                                              child: ($ Id.Lit_ArithVarLike __num__)
                                                            )
                                                          redirects: []
                                                        )
                                                      ]
                                                    )
                                                  redirects: []
                                                )
                                                (command.If
                                                  arms: [
                                                    (if_arm
                                                      cond: 
                                                        (condition.Shell
                                                          commands: [
                                                            (command.DParen
                                                              child: 
                                                                (arith_expr.Binary
                                                                  op_id: Id.Arith_Less
                                                                  left: 
                                                                    ($ Id.Lit_ArithVarLike __max__)
                                                                  right: 
                                                                    ($ Id.Lit_ArithVarLike __num__)
                                                                )
                                                              redirects: []
                                                            )
                                                          ]
                                                        )
                                                      action: [
                                                        (command.DParen
                                                          child: 
                                                            (arith_expr.BinaryAssign
                                                              op_id: Id.Arith_Equal
                                                              left: ($ Id.Lit_ArithVarLike __max__)
                                                              right: ($ Id.Lit_ArithVarLike __num__)
                                                            )
                                                          redirects: []
                                                        )
                                                      ]
                                                      spids: [2318 2332]
                                                    )
                                                  ]
                                                  else_action: []
                                                  redirects: []
                                                )
                                                (command.If
                                                  arms: [
                                                    (if_arm
                                                      cond: 
                                                        (condition.Shell
                                                          commands: [
                                                            (command.DBracket
                                                              expr: 
                                                                (bool_expr.LogicalNot
                                                                  child: 
                                                                    (bool_expr.WordTest
                                                                      w: 
                                                                        {
                                                                          ($ Id.VSub_DollarName 
__preserve__
                                                                          )
                                                                        }
                                                                    )
                                                                )
                                                              redirects: []
                                                            )
                                                          ]
                                                        )
                                                      action: [
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: 
                                                                (sh_lhs_expr.IndexedName
                                                                  left: 
                                                                    <Id.Lit_ArrayLhsOpen '__keep__['>
                                                                  name: __keep__
                                                                  index: 
                                                                    {($ Id.VSub_DollarName __num__)}
                                                                )
                                                              op: assign_op.Equal
                                                              rhs: {<1>}
                                                              spids: [2360]
                                                            )
                                                          ]
                                                          redirects: []
                                                        )
                                                      ]
                                                      spids: [2347 2358]
                                                    )
                                                  ]
                                                  else_action: []
                                                  redirects: []
                                                )
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: 
                                                        (sh_lhs_expr.IndexedName
                                                          left: <Id.Lit_ArrayLhsOpen '__text__['>
                                                          name: __text__
                                                          index: {($ Id.VSub_DollarName __num__)}
                                                        )
                                                      op: assign_op.Equal
                                                      rhs: {($ Id.VSub_DollarName __line__)}
                                                      spids: [2371]
                                                    )
                                                  ]
                                                  redirects: []
                                                )
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: 
                                                        (sh_lhs_expr.IndexedName
                                                          left: <Id.Lit_ArrayLhsOpen '__index__['>
                                                          name: __index__
                                                          index: {(DQ ($ Id.VSub_DollarName __line__))}
                                                        )
                                                      op: assign_op.Equal
                                                      rhs: {($ Id.VSub_DollarName __num__)}
                                                      spids: [2379]
                                                    )
                                                  ]
                                                  redirects: []
                                                )
                                                (command.DParen
                                                  child: 
                                                    (arith_expr.UnaryAssign
                                                      op_id: Id.Node_PostDPlus
                                                      child: ($ Id.Lit_ArithVarLike __num__)
                                                    )
                                                  redirects: []
                                                )
                                              ]
                                              redirects: []
                                            )
                                          ]
                                          spids: [2224 2233]
                                        )
                                      ]
                                      else_action: []
                                      redirects: []
                                    )
                                  ]
                                  spids: [2186 2200 2406 -1]
                                )
                              ]
                              redirects: []
                            )
                          ]
                        )
                      redirects: []
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.DParen
                                  child: 
                                    (arith_expr.Binary
                                      op_id: Id.Arith_Less
                                      left: ($ Id.Lit_ArithVarLike __max__)
                                      right: ($ Id.Lit_ArithVarLike __num__)
                                    )
                                  redirects: []
                                )
                              ]
                            )
                          action: [
                            (command.DParen
                              child: 
                                (arith_expr.BinaryAssign
                                  op_id: Id.Arith_Equal
                                  left: ($ Id.Lit_ArithVarLike __max__)
                                  right: ($ Id.Lit_ArithVarLike __num__)
                                )
                              redirects: []
                            )
                          ]
                          spids: [2415 2429]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.DBracket
                                  expr: (bool_expr.WordTest w:{($ Id.VSub_DollarName __debug__)})
                                  redirects: []
                                )
                              ]
                            )
                          action: [
                            (command.ForExpr
                              init: 
                                (arith_expr.BinaryAssign
                                  op_id: Id.Arith_Equal
                                  left: ($ Id.Lit_ArithVarLike __num__)
                                  right: {<Id.Lit_Digits 1>}
                                )
                              cond: 
                                (arith_expr.Binary
                                  op_id: Id.Arith_LessEqual
                                  left: ($ Id.Lit_ArithVarLike __num__)
                                  right: ($ Id.Lit_ArithVarLike __max__)
                                )
                              update: 
                                (arith_expr.UnaryAssign
                                  op_id: Id.Node_PostDPlus
                                  child: ($ Id.Lit_ArithVarLike __num__)
                                )
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.WordTest
                                                      w: 
                                                        {
                                                          (braced_var_sub
                                                            left: <Id.Left_DollarBrace '${'>
                                                            token: <Id.VSub_Name __text__>
                                                            var_name: __text__
                                                            bracket_op: 
                                                              (bracket_op.ArrayIndex
                                                                expr: {($ Id.VSub_DollarName __num__)}
                                                              )
                                                            right: <Id.Right_DollarBrace '}'>
                                                          )
                                                        }
                                                    )
                                                  redirects: []
                                                )
                                              ]
                                            )
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: 
                                                    (condition.Shell
                                                      commands: [
                                                        (command.DParen
                                                          child: 
                                                            (arith_expr.Binary
                                                              op_id: Id.Arith_Great
                                                              left: ($ Id.Lit_ArithVarLike __num__)
                                                              right: ($ Id.Lit_ArithVarLike __new__)
                                                            )
                                                          redirects: []
                                                        )
                                                      ]
                                                    )
                                                  action: [
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: 
                                                            (condition.Shell
                                                              commands: [
                                                                (command.DBracket
                                                                  expr: 
                                                                    (bool_expr.LogicalNot
                                                                      child: 
                                                                        (bool_expr.WordTest
                                                                          w: 
                                                                            {
                                                                              (braced_var_sub
                                                                                left: 
                                                                                  <
Id.Left_DollarBrace '${'
                                                                                  >
                                                                                token: 
                                                                                  <Id.VSub_Name 
__keep__
                                                                                  >
                                                                                var_name: __keep__
                                                                                bracket_op: 
                                                                                  (bracket_op.ArrayIndex
                                                                                    expr: 
                                                                                      {
                                                                                        ($ 
Id.VSub_DollarName __num__
                                                                                        )
                                                                                      }
                                                                                  )
                                                                                right: 
                                                                                  <
Id.Right_DollarBrace '}'
                                                                                  >
                                                                              )
                                                                            }
                                                                        )
                                                                    )
                                                                  redirects: []
                                                                )
                                                              ]
                                                            )
                                                          action: [
                                                            (C {<print>} {<-r>} {<-u2>} {<-->} 
                                                              {($ Id.VSub_DollarName __num__)} {<HUH>} 
                                                              {(SQ <'"'>) 
                                                                (DQ 
                                                                  (braced_var_sub
                                                                    left: <Id.Left_DollarBrace '${'>
                                                                    token: <Id.VSub_Name __text__>
                                                                    var_name: __text__
                                                                    bracket_op: 
                                                                      (bracket_op.ArrayIndex
                                                                        expr: 
                                                                          {
                                                                            ($ Id.VSub_DollarName 
__num__
                                                                            )
                                                                          }
                                                                      )
                                                                    right: <Id.Right_DollarBrace '}'>
                                                                  )
                                                                ) (SQ <'"'>)
                                                              }
                                                            )
                                                          ]
                                                          spids: [2510 2526]
                                                        )
                                                      ]
                                                      else_action: [
                                                        (C {<print>} {<-r>} {<-u2>} {<-->} 
                                                          {($ Id.VSub_DollarName __num__)} {<NEW>} 
                                                          {(SQ <'"'>) 
                                                            (DQ 
                                                              (braced_var_sub
                                                                left: <Id.Left_DollarBrace '${'>
                                                                token: <Id.VSub_Name __text__>
                                                                var_name: __text__
                                                                bracket_op: 
                                                                  (bracket_op.ArrayIndex
                                                                    expr: 
                                                                      {
                                                                        ($ Id.VSub_DollarName __num__)
                                                                      }
                                                                  )
                                                                right: <Id.Right_DollarBrace '}'>
                                                              )
                                                            ) (SQ <'"'>)
                                                          }
                                                        )
                                                      ]
                                                      redirects: []
                                                    )
                                                  ]
                                                  spids: [2494 2508]
                                                )
                                                (if_arm
                                                  cond: 
                                                    (condition.Shell
                                                      commands: [
                                                        (command.DBracket
                                                          expr: 
                                                            (bool_expr.WordTest
                                                              w: 
                                                                {
                                                                  (braced_var_sub
                                                                    left: <Id.Left_DollarBrace '${'>
                                                                    token: <Id.VSub_Name __keep__>
                                                                    var_name: __keep__
                                                                    bracket_op: 
                                                                      (bracket_op.ArrayIndex
                                                                        expr: 
                                                                          {
                                                                            ($ Id.VSub_DollarName 
__num__
                                                                            )
                                                                          }
                                                                      )
                                                                    right: <Id.Right_DollarBrace '}'>
                                                                  )
                                                                }
                                                            )
                                                          redirects: []
                                                        )
                                                      ]
                                                    )
                                                  action: [
                                                    (C {<print>} {<-r>} {<-u2>} {<-->} 
                                                      {($ Id.VSub_DollarName __num__)} {<OLD>} 
                                                      {(SQ <'"'>) 
                                                        (DQ 
                                                          (braced_var_sub
                                                            left: <Id.Left_DollarBrace '${'>
                                                            token: <Id.VSub_Name __text__>
                                                            var_name: __text__
                                                            bracket_op: 
                                                              (bracket_op.ArrayIndex
                                                                expr: {($ Id.VSub_DollarName __num__)}
                                                              )
                                                            right: <Id.Right_DollarBrace '}'>
                                                          )
                                                        ) (SQ <'"'>)
                                                      }
                                                    )
                                                  ]
                                                  spids: [2589 2603]
                                                )
                                              ]
                                              else_action: [
                                                (C {<print>} {<-r>} {<-u2>} {<-->} 
                                                  {($ Id.VSub_DollarName __num__)} {<XXX>} 
                                                  {(SQ <'"'>) 
                                                    (DQ 
                                                      (braced_var_sub
                                                        left: <Id.Left_DollarBrace '${'>
                                                        token: <Id.VSub_Name __text__>
                                                        var_name: __text__
                                                        bracket_op: 
                                                          (bracket_op.ArrayIndex
                                                            expr: {($ Id.VSub_DollarName __num__)}
                                                          )
                                                        right: <Id.Right_DollarBrace '}'>
                                                      )
                                                    ) (SQ <'"'>)
                                                  }
                                                )
                                              ]
                                              redirects: []
                                            )
                                          ]
                                          spids: [2478 2492]
                                        )
                                      ]
                                      else_action: []
                                      redirects: []
                                    )
                                  ]
                                )
                              redirects: []
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Exit exit>
                              arg_word: {<0>}
                            )
                          ]
                          spids: [2444 2453]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.LogicalNot
                                      child: 
                                        (bool_expr.WordTest
                                          w: {($ Id.VSub_DollarName __preserve__)}
                                        )
                                    )
                                  redirects: []
                                )
                              ]
                            )
                          action: [
                            (command.ForExpr
                              init: 
                                (arith_expr.BinaryAssign
                                  op_id: Id.Arith_Equal
                                  left: ($ Id.Lit_ArithVarLike __num__)
                                  right: {<Id.Lit_Digits 1>}
                                )
                              cond: 
                                (arith_expr.Binary
                                  op_id: Id.Arith_Less
                                  left: ($ Id.Lit_ArithVarLike __num__)
                                  right: ($ Id.Lit_ArithVarLike __new__)
                                )
                              update: 
                                (arith_expr.UnaryAssign
                                  op_id: Id.Node_PostDPlus
                                  child: ($ Id.Lit_ArithVarLike __num__)
                                )
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.LogicalAnd
                                                      left: 
                                                        (bool_expr.WordTest
                                                          w: 
                                                            {
                                                              (braced_var_sub
                                                                left: <Id.Left_DollarBrace '${'>
                                                                token: <Id.VSub_Name __text__>
                                                                var_name: __text__
                                                                bracket_op: 
                                                                  (bracket_op.ArrayIndex
                                                                    expr: 
                                                                      {
                                                                        ($ Id.VSub_DollarName __num__)
                                                                      }
                                                                  )
                                                                right: <Id.Right_DollarBrace '}'>
                                                              )
                                                            }
                                                        )
                                                      right: 
                                                        (bool_expr.LogicalNot
                                                          child: 
                                                            (bool_expr.WordTest
                                                              w: 
                                                                {
                                                                  (braced_var_sub
                                                                    left: <Id.Left_DollarBrace '${'>
                                                                    token: <Id.VSub_Name __keep__>
                                                                    var_name: __keep__
                                                                    bracket_op: 
                                                                      (bracket_op.ArrayIndex
                                                                        expr: 
                                                                          {
                                                                            ($ Id.VSub_DollarName 
__num__
                                                                            )
                                                                          }
                                                                      )
                                                                    right: <Id.Right_DollarBrace '}'>
                                                                  )
                                                                }
                                                            )
                                                        )
                                                    )
                                                  redirects: []
                                                )
                                              ]
                                            )
                                          action: [
                                            (command.DParen
                                              child: 
                                                (arith_expr.UnaryAssign
                                                  op_id: Id.Node_PostDPlus
                                                  child: ($ Id.Lit_ArithVarLike __ndrop__)
                                                )
                                              redirects: []
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: 
                                                    (sh_lhs_expr.IndexedName
                                                      left: <Id.Lit_ArrayLhsOpen '__drop__['>
                                                      name: __drop__
                                                      index: ($ Id.Lit_ArithVarLike __ndrop__)
                                                    )
                                                  op: assign_op.Equal
                                                  rhs: {($ Id.VSub_DollarName __num__)}
                                                  spids: [2756]
                                                )
                                              ]
                                              redirects: []
                                            )
                                          ]
                                          spids: [2720 2745]
                                        )
                                      ]
                                      else_action: []
                                      redirects: []
                                    )
                                  ]
                                )
                              redirects: []
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: (bool_expr.WordTest w:{($ Id.VSub_DollarName __verbose__)})
                                  redirects: []
                                )
                                (C {<print>} {<-u2>} 
                                  {($ Id.VSub_DollarName __command__) <Id.Lit_Colon ':'>} 
                                  {<old> <Id.Lit_Colon ':'> <1-> 
                                    (word_part.ArithSub
                                      anode: 
                                        (arith_expr.Binary
                                          op_id: Id.Arith_Minus
                                          left: ($ Id.Lit_ArithVarLike __new__)
                                          right: {<Id.Lit_Digits 1>}
                                        )
                                    )
                                  } {<new> <Id.Lit_Colon ':'> ($ Id.VSub_DollarName __new__) <-> ($ Id.VSub_DollarName __max__)} {<drop>} 
                                  {($ Id.VSub_DollarName __ndrop__)} {<add>} 
                                  {
                                    (word_part.ArithSub
                                      anode: 
                                        (arith_expr.Binary
                                          op_id: Id.Arith_Plus
                                          left: 
                                            (arith_expr.Binary
                                              op_id: Id.Arith_Minus
                                              left: ($ Id.Lit_ArithVarLike __max__)
                                              right: ($ Id.Lit_ArithVarLike __new__)
                                            )
                                          right: {<Id.Lit_Digits 1>}
                                        )
                                    )
                                  }
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.DParen
                                          child: ($ Id.Lit_ArithVarLike __ndrop__)
                                          redirects: []
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ForExpr
                                      init: 
                                        (arith_expr.BinaryAssign
                                          op_id: Id.Arith_Equal
                                          left: ($ Id.Lit_ArithVarLike __i__)
                                          right: {<Id.Lit_Digits 1>}
                                        )
                                      cond: 
                                        (arith_expr.Binary
                                          op_id: Id.Arith_LessEqual
                                          left: ($ Id.Lit_ArithVarLike __i__)
                                          right: ($ Id.Lit_ArithVarLike __ndrop__)
                                        )
                                      update: 
                                        (arith_expr.UnaryAssign
                                          op_id: Id.Node_PostDPlus
                                          child: ($ Id.Lit_ArithVarLike __i__)
                                        )
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (command.DParen
                                              child: 
                                                (arith_expr.BinaryAssign
                                                  op_id: Id.Arith_Equal
                                                  left: ($ Id.Lit_ArithVarLike __old__)
                                                  right: 
                                                    {
                                                      (braced_var_sub
                                                        left: <Id.Left_DollarBrace '${'>
                                                        token: <Id.VSub_Name __drop__>
                                                        var_name: __drop__
                                                        bracket_op: 
                                                          (bracket_op.ArrayIndex
                                                            expr: {($ Id.VSub_DollarName __i__)}
                                                          )
                                                        right: <Id.Right_DollarBrace '}'>
                                                      )
                                                    }
                                                )
                                              redirects: []
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: 
                                                    (sh_lhs_expr.IndexedName
                                                      left: <Id.Lit_ArrayLhsOpen '__oz__['>
                                                      name: __oz__
                                                      index: ($ Id.Lit_ArithVarLike __i__)
                                                    )
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (command_sub
                                                        left_token: <Id.Left_DollarParen '$('>
                                                        child: 
                                                          (command.Pipeline
                                                            children: [
                                                              (C {<print>} {<-r>} {<-->} 
                                                                {
                                                                  (DQ 
                                                                    (word_part.EscapedLiteral
                                                                      token: 
                                                                        <Id.Lit_EscapedChar '\\"'>
                                                                      ch: '"'
                                                                    ) 
                                                                    (braced_var_sub
                                                                      left: 
                                                                        <Id.Left_DollarBrace '${'>
                                                                      token: <Id.VSub_Name __text__>
                                                                      var_name: __text__
                                                                      bracket_op: 
                                                                        (bracket_op.ArrayIndex
                                                                          expr: 
                                                                            {
                                                                              ($ Id.VSub_DollarName 
__old__
                                                                              )
                                                                            }
                                                                        )
                                                                      right: 
                                                                        <Id.Right_DollarBrace '}'>
                                                                    ) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"')
                                                                  )
                                                                }
                                                              )
                                                              (C {<gzip>})
                                                              (C {<wc>} {<-c>})
                                                            ]
                                                            negated: F
                                                            stderr_indices: []
                                                          )
                                                        right: <Id.Eof_RParen _>
                                                      )
                                                    }
                                                  spids: [2867]
                                                )
                                              ]
                                              redirects: []
                                            )
                                          ]
                                        )
                                      redirects: []
                                    )
                                    (command.ForExpr
                                      init: 
                                        (arith_expr.BinaryAssign
                                          op_id: Id.Arith_Equal
                                          left: ($ Id.Lit_ArithVarLike __num__)
                                          right: ($ Id.Lit_ArithVarLike __new__)
                                        )
                                      cond: 
                                        (arith_expr.Binary
                                          op_id: Id.Arith_LessEqual
                                          left: ($ Id.Lit_ArithVarLike __num__)
                                          right: ($ Id.Lit_ArithVarLike __max__)
                                        )
                                      update: 
                                        (arith_expr.UnaryAssign
                                          op_id: Id.Node_PostDPlus
                                          child: ($ Id.Lit_ArithVarLike __num__)
                                        )
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (command.AndOr
                                              ops: [Id.Op_DPipe]
                                              children: [
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.WordTest
                                                      w: 
                                                        {
                                                          (braced_var_sub
                                                            left: <Id.Left_DollarBrace '${'>
                                                            token: <Id.VSub_Name __text__>
                                                            var_name: __text__
                                                            bracket_op: 
                                                              (bracket_op.ArrayIndex
                                                                expr: {($ Id.VSub_DollarName __num__)}
                                                              )
                                                            right: <Id.Right_DollarBrace '}'>
                                                          )
                                                        }
                                                    )
                                                  redirects: []
                                                )
                                                (command.ControlFlow
                                                  token: <Id.ControlFlow_Continue continue>
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: 
                                                    (sh_lhs_expr.Name
                                                      left: <Id.Lit_VarLike '__nz__='>
                                                      name: __nz__
                                                    )
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (command_sub
                                                        left_token: <Id.Left_DollarParen '$('>
                                                        child: 
                                                          (command.Pipeline
                                                            children: [
                                                              (C {<print>} {<-r>} {<-->} 
                                                                {
                                                                  (DQ 
                                                                    (word_part.EscapedLiteral
                                                                      token: 
                                                                        <Id.Lit_EscapedChar '\\"'>
                                                                      ch: '"'
                                                                    ) 
                                                                    (braced_var_sub
                                                                      left: 
                                                                        <Id.Left_DollarBrace '${'>
                                                                      token: <Id.VSub_Name __text__>
                                                                      var_name: __text__
                                                                      bracket_op: 
                                                                        (bracket_op.ArrayIndex
                                                                          expr: 
                                                                            {
                                                                              ($ Id.VSub_DollarName 
__num__
                                                                              )
                                                                            }
                                                                        )
                                                                      right: 
                                                                        <Id.Right_DollarBrace '}'>
                                                                    ) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"')
                                                                  )
                                                                }
                                                              )
                                                              (C {<gzip>})
                                                              (C {<wc>} {<-c>})
                                                            ]
                                                            negated: F
                                                            stderr_indices: []
                                                          )
                                                        right: <Id.Eof_RParen _>
                                                      )
                                                    }
                                                  spids: [2944]
                                                )
                                              ]
                                              redirects: []
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: 
                                                    (sh_lhs_expr.Name
                                                      left: <Id.Lit_VarLike '__hit__='>
                                                      name: __hit__
                                                    )
                                                  op: assign_op.Equal
                                                  rhs: {<0>}
                                                  spids: [2975]
                                                )
                                              ]
                                              redirects: []
                                            )
                                            (command.DParen
                                              child: 
                                                (arith_expr.BinaryAssign
                                                  op_id: Id.Arith_Equal
                                                  left: ($ Id.Lit_ArithVarLike __bz__)
                                                  right: ($ Id.Lit_ArithVarLike __similar__)
                                                )
                                              redirects: []
                                            )
                                            (command.ForExpr
                                              init: 
                                                (arith_expr.BinaryAssign
                                                  op_id: Id.Arith_Equal
                                                  left: ($ Id.Lit_ArithVarLike __i__)
                                                  right: {<Id.Lit_Digits 1>}
                                                )
                                              cond: 
                                                (arith_expr.Binary
                                                  op_id: Id.Arith_LessEqual
                                                  left: ($ Id.Lit_ArithVarLike __i__)
                                                  right: ($ Id.Lit_ArithVarLike __ndrop__)
                                                )
                                              update: 
                                                (arith_expr.UnaryAssign
                                                  op_id: Id.Node_PostDPlus
                                                  child: ($ Id.Lit_ArithVarLike __i__)
                                                )
                                              body: 
                                                (command.DoGroup
                                                  children: [
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: 
                                                            (condition.Shell
                                                              commands: [
                                                                (command.DParen
                                                                  child: 
                                                                    (arith_expr.BinaryAssign
                                                                      op_id: Id.Arith_Equal
                                                                      left: 
                                                                        ($ Id.Lit_ArithVarLike 
__old__
                                                                        )
                                                                      right: 
                                                                        {
                                                                          (braced_var_sub
                                                                            left: 
                                                                              <Id.Left_DollarBrace 
'${'
                                                                              >
                                                                            token: 
                                                                              <Id.VSub_Name __drop__>
                                                                            var_name: __drop__
                                                                            bracket_op: 
                                                                              (bracket_op.ArrayIndex
                                                                                expr: 
                                                                                  {
                                                                                    ($ 
Id.VSub_DollarName __i__
                                                                                    )
                                                                                  }
                                                                              )
                                                                            right: 
                                                                              <Id.Right_DollarBrace 
'}'
                                                                              >
                                                                          )
                                                                        }
                                                                    )
                                                                  redirects: []
                                                                )
                                                              ]
                                                            )
                                                          action: [
                                                            (command.ShAssignment
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (sh_lhs_expr.Name
                                                                      left: <Id.Lit_VarLike '__z__='>
                                                                      name: __z__
                                                                    )
                                                                  op: assign_op.Equal
                                                                  rhs: 
                                                                    {
                                                                      (command_sub
                                                                        left_token: 
                                                                          <Id.Left_DollarParen '$('>
                                                                        child: 
                                                                          (command.Pipeline
                                                                            children: [
                                                                              (C {<print>} {<-r>} {<-->} 
                                                                                {
                                                                                  (DQ 
                                                                                    (word_part.EscapedLiteral
                                                                                      token: 
                                                                                        <
Id.Lit_EscapedChar '\\"'
                                                                                        >
                                                                                      ch: '"'
                                                                                    ) 
                                                                                    (braced_var_sub
                                                                                      left: 
                                                                                        <
Id.Left_DollarBrace '${'
                                                                                        >
                                                                                      token: 
                                                                                        <
Id.VSub_Name __text__
                                                                                        >
                                                                                      var_name: 
__text__
                                                                                      bracket_op: 
                                                                                        (bracket_op.ArrayIndex
                                                                                          expr: 
                                                                                            {
                                                                                              ($ 
Id.VSub_DollarName __old__
                                                                                              )
                                                                                            }
                                                                                        )
                                                                                      right: 
                                                                                        <
Id.Right_DollarBrace '}'
                                                                                        >
                                                                                    ) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"')
                                                                                  ) 
                                                                                  (DQ 
                                                                                    (word_part.EscapedLiteral
                                                                                      token: 
                                                                                        <
Id.Lit_EscapedChar '\\"'
                                                                                        >
                                                                                      ch: '"'
                                                                                    ) 
                                                                                    (braced_var_sub
                                                                                      left: 
                                                                                        <
Id.Left_DollarBrace '${'
                                                                                        >
                                                                                      token: 
                                                                                        <
Id.VSub_Name __text__
                                                                                        >
                                                                                      var_name: 
__text__
                                                                                      bracket_op: 
                                                                                        (bracket_op.ArrayIndex
                                                                                          expr: 
                                                                                            {
                                                                                              ($ 
Id.VSub_DollarName __num__
                                                                                              )
                                                                                            }
                                                                                        )
                                                                                      right: 
                                                                                        <
Id.Right_DollarBrace '}'
                                                                                        >
                                                                                    ) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"')
                                                                                  )
                                                                                }
                                                                              )
                                                                              (C {<gzip>})
                                                                              (C {<wc>} {<-c>})
                                                                            ]
                                                                            negated: F
                                                                            stderr_indices: []
                                                                          )
                                                                        right: <Id.Eof_RParen _>
                                                                      )
                                                                    }
                                                                  spids: [3031]
                                                                )
                                                              ]
                                                              redirects: []
                                                            )
                                                            (command.DParen
                                                              child: 
                                                                (arith_expr.BinaryAssign
                                                                  op_id: Id.Arith_Equal
                                                                  left: ($ Id.Lit_ArithVarLike __z__)
                                                                  right: 
                                                                    (arith_expr.Binary
                                                                      op_id: Id.Arith_Minus
                                                                      left: 
                                                                        (arith_expr.Binary
                                                                          op_id: Id.Arith_Slash
                                                                          left: 
                                                                            (arith_expr.Binary
                                                                              op_id: Id.Arith_Star
                                                                              left: 
                                                                                ($ 
Id.Lit_ArithVarLike __z__
                                                                                )
                                                                              right: 
                                                                                {<Id.Lit_Digits 200>}
                                                                            )
                                                                          right: 
                                                                            (arith_expr.Binary
                                                                              op_id: Id.Arith_Plus
                                                                              left: 
                                                                                {
                                                                                  (braced_var_sub
                                                                                    left: 
                                                                                      <
Id.Left_DollarBrace '${'
                                                                                      >
                                                                                    token: 
                                                                                      <Id.VSub_Name 
__oz__
                                                                                      >
                                                                                    var_name: __oz__
                                                                                    bracket_op: 
                                                                                      (bracket_op.ArrayIndex
                                                                                        expr: 
                                                                                          ($ 
Id.Lit_ArithVarLike __i__
                                                                                          )
                                                                                      )
                                                                                    right: 
                                                                                      <
Id.Right_DollarBrace '}'
                                                                                      >
                                                                                  )
                                                                                }
                                                                              right: 
                                                                                {
                                                                                  ($ 
Id.VSub_DollarName __nz__
                                                                                  )
                                                                                }
                                                                            )
                                                                        )
                                                                      right: {<Id.Lit_Digits 100>}
                                                                    )
                                                                )
                                                              redirects: []
                                                            )
                                                            (command.If
                                                              arms: [
                                                                (if_arm
                                                                  cond: 
                                                                    (condition.Shell
                                                                      commands: [
                                                                        (command.DParen
                                                                          child: 
                                                                            (arith_expr.Binary
                                                                              op_id: Id.Arith_Less
                                                                              left: 
                                                                                ($ 
Id.Lit_ArithVarLike __z__
                                                                                )
                                                                              right: 
                                                                                ($ 
Id.Lit_ArithVarLike __bz__
                                                                                )
                                                                            )
                                                                          redirects: []
                                                                        )
                                                                      ]
                                                                    )
                                                                  action: [
                                                                    (command.DParen
                                                                      child: 
                                                                        (arith_expr.BinaryAssign
                                                                          op_id: Id.Arith_Equal
                                                                          left: 
                                                                            ($ Id.Lit_ArithVarLike 
__bz__
                                                                            )
                                                                          right: 
                                                                            ($ Id.Lit_ArithVarLike 
__z__
                                                                            )
                                                                        )
                                                                      redirects: []
                                                                    )
                                                                    (command.DParen
                                                                      child: 
                                                                        (arith_expr.BinaryAssign
                                                                          op_id: Id.Arith_Equal
                                                                          left: 
                                                                            ($ Id.Lit_ArithVarLike 
__hit__
                                                                            )
                                                                          right: 
                                                                            ($ Id.Lit_ArithVarLike 
__old__
                                                                            )
                                                                        )
                                                                      redirects: []
                                                                    )
                                                                    (command.DParen
                                                                      child: 
                                                                        (arith_expr.BinaryAssign
                                                                          op_id: Id.Arith_Equal
                                                                          left: 
                                                                            ($ Id.Lit_ArithVarLike 
__hit_i__
                                                                            )
                                                                          right: 
                                                                            ($ Id.Lit_ArithVarLike 
__i__
                                                                            )
                                                                        )
                                                                      redirects: []
                                                                    )
                                                                  ]
                                                                  spids: [3109 3123]
                                                                )
                                                              ]
                                                              else_action: []
                                                              redirects: []
                                                            )
                                                          ]
                                                          spids: [3012 3029]
                                                        )
                                                      ]
                                                      else_action: []
                                                      redirects: []
                                                    )
                                                  ]
                                                )
                                              redirects: []
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: 
                                                    (condition.Shell
                                                      commands: [
                                                        (command.DParen
                                                          child: ($ Id.Lit_ArithVarLike __hit__)
                                                          redirects: []
                                                        )
                                                      ]
                                                    )
                                                  action: [
                                                    (command.AndOr
                                                      ops: [Id.Op_DAmp]
                                                      children: [
                                                        (command.DBracket
                                                          expr: 
                                                            (bool_expr.WordTest
                                                              w: {($ Id.VSub_DollarName __verbose__)}
                                                            )
                                                          redirects: []
                                                        )
                                                        (C {<print>} {<-u2>} 
                                                          {($ Id.VSub_DollarName __command__) 
                                                            <Id.Lit_Colon ':'>
                                                          } {($ Id.VSub_DollarName __hit__)} {($ Id.VSub_DollarName __num__)} {($ Id.VSub_DollarName __bz__)}
                                                        )
                                                      ]
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: 
                                                            (sh_lhs_expr.IndexedName
                                                              left: <Id.Lit_ArrayLhsOpen '__text__['>
                                                              name: __text__
                                                              index: {($ Id.VSub_DollarName __hit__)}
                                                            )
                                                          op: assign_op.Equal
                                                          rhs: 
                                                            {
                                                              (braced_var_sub
                                                                left: <Id.Left_DollarBrace '${'>
                                                                token: <Id.VSub_Name __text__>
                                                                var_name: __text__
                                                                bracket_op: 
                                                                  (bracket_op.ArrayIndex
                                                                    expr: 
                                                                      {
                                                                        ($ Id.VSub_DollarName __num__)
                                                                      }
                                                                  )
                                                                right: <Id.Right_DollarBrace '}'>
                                                              )
                                                            }
                                                          spids: [3198]
                                                        )
                                                      ]
                                                      redirects: []
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: 
                                                            (sh_lhs_expr.IndexedName
                                                              left: <Id.Lit_ArrayLhsOpen '__keep__['>
                                                              name: __keep__
                                                              index: {($ Id.VSub_DollarName __hit__)}
                                                            )
                                                          op: assign_op.Equal
                                                          rhs: {<1>}
                                                          spids: [3211]
                                                        )
                                                      ]
                                                      redirects: []
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: 
                                                            (sh_lhs_expr.IndexedName
                                                              left: <Id.Lit_ArrayLhsOpen '__drop__['>
                                                              name: __drop__
                                                              index: 
                                                                {($ Id.VSub_DollarName __hit_i__)}
                                                            )
                                                          op: assign_op.Equal
                                                          rhs: {<0>}
                                                          spids: [3219]
                                                        )
                                                      ]
                                                      redirects: []
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: 
                                                            (sh_lhs_expr.IndexedName
                                                              left: <Id.Lit_ArrayLhsOpen '__text__['>
                                                              name: __text__
                                                              index: {($ Id.VSub_DollarName __num__)}
                                                            )
                                                          op: assign_op.Equal
                                                          rhs: (rhs_word.Empty)
                                                          spids: [3227]
                                                        )
                                                      ]
                                                      redirects: []
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: 
                                                            (sh_lhs_expr.IndexedName
                                                              left: <Id.Lit_ArrayLhsOpen '__keep__['>
                                                              name: __keep__
                                                              index: {($ Id.VSub_DollarName __num__)}
                                                            )
                                                          op: assign_op.Equal
                                                          rhs: (rhs_word.Empty)
                                                          spids: [3234]
                                                        )
                                                      ]
                                                      redirects: []
                                                    )
                                                  ]
                                                  spids: [3164 3174]
                                                )
                                              ]
                                              else_action: []
                                              redirects: []
                                            )
                                          ]
                                        )
                                      redirects: []
                                    )
                                  ]
                                  spids: [2817 2827]
                                )
                              ]
                              else_action: []
                              redirects: []
                            )
                          ]
                          spids: [2684 2695]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                    (command.ForExpr
                      init: 
                        (arith_expr.BinaryAssign
                          op_id: Id.Arith_Equal
                          left: ($ Id.Lit_ArithVarLike __num__)
                          right: {<Id.Lit_Digits 1>}
                        )
                      cond: 
                        (arith_expr.Binary
                          op_id: Id.Arith_LessEqual
                          left: ($ Id.Lit_ArithVarLike __num__)
                          right: ($ Id.Lit_ArithVarLike __max__)
                        )
                      update: 
                        (arith_expr.UnaryAssign
                          op_id: Id.Node_PostDPlus
                          child: ($ Id.Lit_ArithVarLike __num__)
                        )
                      body: 
                        (command.DoGroup
                          children: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.LogicalAnd
                                              left: 
                                                (bool_expr.WordTest
                                                  w: 
                                                    {
                                                      (braced_var_sub
                                                        left: <Id.Left_DollarBrace '${'>
                                                        token: <Id.VSub_Name __text__>
                                                        var_name: __text__
                                                        bracket_op: 
                                                          (bracket_op.ArrayIndex
                                                            expr: {($ Id.VSub_DollarName __num__)}
                                                          )
                                                        right: <Id.Right_DollarBrace '}'>
                                                      )
                                                    }
                                                )
                                              right: 
                                                (bool_expr.LogicalOr
                                                  left: 
                                                    (bool_expr.WordTest
                                                      w: {($ Id.VSub_DollarName __preserve__)}
                                                    )
                                                  right: 
                                                    (bool_expr.WordTest
                                                      w: 
                                                        {
                                                          (braced_var_sub
                                                            left: <Id.Left_DollarBrace '${'>
                                                            token: <Id.VSub_Name __keep__>
                                                            var_name: __keep__
                                                            bracket_op: 
                                                              (bracket_op.ArrayIndex
                                                                expr: {($ Id.VSub_DollarName __num__)}
                                                              )
                                                            right: <Id.Right_DollarBrace '}'>
                                                          )
                                                        }
                                                    )
                                                )
                                            )
                                          redirects: []
                                        )
                                      ]
                                    )
                                  action: [
                                    (C {<print>} {<-r>} {<-->} {($ Id.VSub_DollarName __num__)} 
                                      {
                                        (DQ 
                                          (word_part.EscapedLiteral
                                            token: <Id.Lit_EscapedChar '\\"'>
                                            ch: '"'
                                          ) 
                                          (braced_var_sub
                                            left: <Id.Left_DollarBrace '${'>
                                            token: <Id.VSub_Name __text__>
                                            var_name: __text__
                                            bracket_op: 
                                              (bracket_op.ArrayIndex
                                                expr: {($ Id.VSub_DollarName __num__)}
                                              )
                                            right: <Id.Right_DollarBrace '}'>
                                          ) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"')
                                        )
                                      }
                                    )
                                  ]
                                  spids: [3280 3311]
                                )
                              ]
                              else_action: []
                              redirects: []
                            )
                          ]
                        )
                      redirects: []
                    )
                  ]
                  redirects: []
                  right: <Id.Lit_RBrace '}'>
                )
              ]
              negated: F
              stderr_indices: []
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobNEqual
                              left: {($ Id.VSub_DollarName __tmp__)}
                              right: {($ Id.VSub_DollarName __out__)}
                            )
                          redirects: []
                        )
                      ]
                    )
                  action: [
                    (command.Simple
                      words: [{<grep>} {<-v>} {(SQ <'^\\$'>)} {($ Id.VSub_DollarName __tmp__)}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(${ Id.VSub_Name __tmp__) <n>}
                        )
                      ]
                      more_env: []
                      do_fork: T
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_f
                              child: {($ Id.VSub_DollarName __out__)}
                            )
                          redirects: []
                        )
                        (command.Simple
                          words: [{<grep>} {<-v>} {(SQ <'^\\$'>)} {($ Id.VSub_DollarName __out__)}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {(${ Id.VSub_Name __tmp__) <o>}
                            )
                          ]
                          more_env: []
                          do_fork: T
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<cmp>} {<-s>} {(${ Id.VSub_Name __tmp__) <n>} {(${ Id.VSub_Name __tmp__) <o>})
                        (BraceGroup
                          left: <Id.Lit_LBrace '{'>
                          children: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_f
                                      child: {($ Id.VSub_DollarName __out__)}
                                    )
                                  redirects: []
                                )
                                (C {<mv>} {($ Id.VSub_DollarName __out__)} 
                                  {($ Id.VSub_DollarName __out__) <.old>}
                                )
                              ]
                            )
                            (C {<mv>} {($ Id.VSub_DollarName __tmp__)} {($ Id.VSub_DollarName __out__)})
                          ]
                          redirects: []
                          right: <Id.Lit_RBrace '}'>
                        )
                      ]
                    )
                  ]
                  spids: [3342 3355]
                )
              ]
              else_action: []
              redirects: []
            )
          ]
          spids: [1225 1241]
        )
      ]
      else_action: []
      redirects: []
    )
    (command.ControlFlow
      token: <Id.ControlFlow_Exit exit>
      arg_word: {($ Id.VSub_DollarName __code__)}
    )
  ]
)