(command.CommandList
  children: [
    (command.ShFunction
      name: __gtar_parse_help_opt
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<opttype>} {<arg>} {<opt>} {<separator>} {<optvar>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:opttype)
                  op: assign_op.Equal
                  rhs: {<long>}
                  spids: [138]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:arg)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number '$2'))}
                  spids: [142]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:opt)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number '$1'))}
                  spids: [148]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:separator)
                  op: assign_op.Equal
                  rhs: {(DQ <' '>)}
                  spids: [154]
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$opt'))}
              arms: [
                (case_arm pat_list:[{<--> <Id.Lit_Star '*'>}] spids:[170 172 175 -1])
                (case_arm
                  pat_list: [{<-> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\?'>)}]
                  action: [(command.ControlFlow token:<Id.ControlFlow_Return return>)]
                  spids: [178 180 185 -1]
                )
                (case_arm
                  pat_list: [{<-> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:opttype)
                          op: assign_op.Equal
                          rhs: {<short>}
                          spids: [193]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:opt)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <Id.VSub_Name opt>
                                suffix_op: (suffix_op.Unary tok:<Id.VOp1_DPound '##'> arg_word:{<->})
                              )
                            }
                          spids: [197]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:separator)
                          op: assign_op.Equal
                          rhs: (word.Empty)
                          spids: [205]
                        )
                      ]
                    )
                  ]
                  spids: [188 190 208 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.Simple
                      words: [{<echo>} {(DQ <'not an option '> ($ Id.VSub_DollarName '$opt'))}]
                      redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                      do_fork: T
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<1>}
                    )
                  ]
                  spids: [211 212 231 -1]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:opt)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name opt>
                        suffix_op: 
                          (suffix_op.PatSub
                            pat: 
                              {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\['>) 
                                <Id.Lit_Other '*'>
                              }
                            replace: {}
                            replace_mode: Id.Lit_Slash
                          )
                      )
                    }
                  spids: [242]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:opt)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name opt>
                        suffix_op: 
                          (suffix_op.PatSub
                            pat: {<'='> <Id.Lit_Other '*'>}
                            replace: {<'='>}
                            replace_mode: Id.Lit_Slash
                          )
                      )
                    }
                  spids: [253]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:opt)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name opt>
                        suffix_op: 
                          (suffix_op.PatSub
                            pat: 
                              {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) 
                                <Id.Lit_Other '*'>
                              }
                            replace: {}
                            replace_mode: Id.Lit_Slash
                          )
                      )
                    }
                  spids: [270]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:opt)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name opt>
                        suffix_op: 
                          (suffix_op.PatSub
                            pat: 
                              {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\''>) 
                                <Id.Lit_Other '*'>
                              }
                            replace: {}
                            replace_mode: Id.Lit_Slash
                          )
                      )
                    }
                  spids: [281]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:opt)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name opt>
                        suffix_op: 
                          (suffix_op.PatSub
                            pat: 
                              {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\;'>) 
                                <Id.Lit_Other '*'>
                              }
                            replace: {}
                            replace_mode: Id.Lit_Slash
                          )
                      )
                    }
                  spids: [292]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:optvar)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$opttype') (SQ <_arg_>) ($ Id.VSub_DollarName '$arg')}
                  spids: [304]
                )
              ]
            )
            (C {<eval>} 
              {
                (DQ ($ Id.VSub_DollarName '$optvar') <'='> 
                  (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) ($ Id.VSub_DollarName '$optvar') 
                  ($ Id.VSub_DollarName '$separator') (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) 
                  (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) ($ Id.VSub_DollarName '$opt') (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>)
                )
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: __gtar_parse_help_line
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<i>})
            (command.ForEach
              iter_name: i
              iter_words: [{($ Id.VSub_Number '$1')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName '$i'))}
                      arms: [
                        (case_arm
                          pat_list: [{<--> <Id.Lit_Star '*'>} {<-> <Id.Lit_Star '*'>}]
                          action: [
                            (C {<__gtar_parse_help_opt>} {(DQ ($ Id.VSub_DollarName '$i'))} 
                              {(DQ ($ Id.VSub_Number '$2'))}
                            )
                          ]
                          spids: [370 375 389 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (command.Sentence
                              child: (command.ControlFlow token:<Id.ControlFlow_Break break>)
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          spids: [397 398 -1 405]
                        )
                      ]
                    )
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: __gnu_tar_parse_help
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<str>} {<line>} {<arg>})
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.Simple
                          words: [{<read>} {<line>}]
                          more_env: [(env_pair name:IFS val:(word.Empty) spids:[432])]
                          do_fork: T
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_EqualTilde
                                          left: {(DQ ($ Id.VSub_DollarName '$line'))}
                                          right: 
                                            {<Id.Lit_Other '^'> <Id.Lit_Other '['> <Id.Lit_Other '['> 
                                              <Id.Lit_Other ':'> <blank> <Id.Lit_Other ':'> <Id.Lit_Other ']'> <Id.Lit_Other ']'> <Id.Lit_Other '{'> <1> <Id.Lit_Other ','> 
                                              <10> <Id.Lit_Other '}'> <Id.Lit_Other '('> <Id.Lit_Other '('> <Id.Lit_Other '('> <Id.Lit_Other ','> 
                                              <Id.Lit_Other '['> <Id.Lit_Other '['> <Id.Lit_Other ':'> <blank> <Id.Lit_Other ':'> <Id.Lit_Other ']'> <Id.Lit_Other ']'> 
                                              <Id.Lit_Other ')'> <Id.Lit_Other '?'> <Id.Lit_Other '('> <--> <Id.Lit_Other '?'> <Id.Lit_Other '('> <Id.Lit_Other '['> 
                                              <Id.Lit_RegexMeta '\\]'> <Id.Lit_RegexMeta '\\['> <a-zA-Z0-9> <Id.Lit_Other '?'> <-> <Id.Lit_Other '='> <Id.Lit_Other ']'> 
                                              <Id.Lit_Other '+'> <Id.Lit_Other ')'> <Id.Lit_Other ')'> <Id.Lit_Other '('> <Id.Lit_Other ','> <Id.Lit_Other '['> 
                                              <Id.Lit_Other '['> <Id.Lit_Other ':'> <space> <Id.Lit_Other ':'> <Id.Lit_Other ']'> <Id.Lit_Other ']'> <Id.Lit_Other ')'> 
                                              <Id.Lit_Other '?'> <Id.Lit_Other ')'> <Id.Lit_Other '+'> <Id.Lit_Other ')'> <Id.Lit_Other .> <Id.Lit_Other '*'> 
                                              <Id.Lit_Other '$'>
                                            }
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:line)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name BASH_REMATCH>
                                        bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 1>})
                                      )
                                    }
                                  spids: [536]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:str)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Name line>
                                          suffix_op: 
                                            (suffix_op.PatSub
                                              pat: {<','>}
                                              replace: {<' '>}
                                              replace_mode: Id.Lit_Slash
                                            )
                                        )
                                      )
                                    }
                                  spids: [545]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:arg)
                                  op: assign_op.Equal
                                  rhs: {<none>}
                                  spids: [575]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_EqualTilde
                                                  left: {(DQ ($ Id.VSub_DollarName '$line'))}
                                                  right: 
                                                    {<--> <Id.Lit_Other '['> <A-Za-z0-9-> 
                                                      <Id.Lit_Other ']'> <Id.Lit_Other '+'> <Id.Lit_Other '('> <Id.Lit_RegexMeta '\\['> <Id.Lit_Other '?'> <Id.Lit_Other ')'> 
                                                      <Id.Lit_Other '='>
                                                    }
                                                )
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.AndOr
                                      ops: [Id.Op_DAmp Id.Op_DPipe]
                                      children: [
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Unary
                                              op_id: Id.BoolUnary_n
                                              child: 
                                                {
                                                  (DQ 
                                                    (braced_var_sub
                                                      token: <Id.VSub_Name BASH_REMATCH>
                                                      bracket_op: 
                                                        (bracket_op.ArrayIndex
                                                          expr: {<Id.Lit_Digits 1>}
                                                        )
                                                    )
                                                  )
                                                }
                                            )
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:arg)
                                              op: assign_op.Equal
                                              rhs: {<opt>}
                                              spids: [623]
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:arg)
                                              op: assign_op.Equal
                                              rhs: {<req>}
                                              spids: [628]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [579 603]
                                )
                              ]
                            )
                            (C {<__gtar_parse_help_line>} {(DQ ($ Id.VSub_DollarName '$str'))} 
                              {(DQ ($ Id.VSub_DollarName '$arg'))}
                            )
                          ]
                          spids: [458 532]
                        )
                      ]
                    )
                  ]
                )
              redirects: [
                (redir
                  op: <Id.Redir_TLess '<<<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: 
                    {
                      (DQ 
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: (C {<tar>} {<--help>})
                        )
                      )
                    }
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:long_opts)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ <'        '> ($ Id.VSub_DollarName '$long_arg_none') <'        '> 
                        ($ Id.VSub_DollarName '$long_arg_opt') <'        '> ($ Id.VSub_DollarName '$long_arg_req')
                      )
                    }
                  spids: [663]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:short_opts)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ ($ Id.VSub_DollarName '$short_arg_none') 
                        ($ Id.VSub_DollarName '$short_arg_opt') ($ Id.VSub_DollarName '$short_arg_req')
                      )
                    }
                  spids: [678]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: __gtar_parse_warnings
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<line>})
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.Simple
                          words: [{<read>} {<line>}]
                          more_env: [(env_pair name:IFS val:(word.Empty) spids:[706])]
                          do_fork: T
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_EqualTilde
                                          left: {($ Id.VSub_DollarName '$line')}
                                          right: 
                                            {<Id.Lit_Other '^'> <Id.Lit_Other '['> <Id.Lit_Other '['> 
                                              <Id.Lit_Other ':'> <blank> <Id.Lit_Other ':'> <Id.Lit_Other ']'> <Id.Lit_Other ']'> <Id.Lit_Other '*'> <-> <Id.Lit_Other '['> 
                                              <Id.Lit_Other '['> <Id.Lit_Other ':'> <blank> <Id.Lit_Other ':'> <Id.Lit_Other ']'> <Id.Lit_Other ']'> <Id.Lit_Other '*'> 
                                              <Id.Lit_Other '['> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\`'>) 
                                              (word_part.EscapedLiteral
                                                token: <Id.Lit_EscapedChar '\\\''>
                                              ) <Id.Lit_Other ']'> <Id.Lit_Other '('> <Id.Lit_Other '['> <a-zA-Z0-9-> <Id.Lit_Other ']'> 
                                              <Id.Lit_Other '+'> <Id.Lit_Other ')'> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\''>) <Id.Lit_Other '$'>
                                            }
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<echo>} 
                              {
                                (DQ 
                                  (braced_var_sub
                                    token: <Id.VSub_Name BASH_REMATCH>
                                    bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 1>})
                                  ) <' no-'> 
                                  (braced_var_sub
                                    token: <Id.VSub_Name BASH_REMATCH>
                                    bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 1>})
                                  )
                                )
                              }
                            )
                          ]
                          spids: [716 758]
                        )
                      ]
                    )
                  ]
                )
              redirects: [
                (redir
                  op: <Id.Redir_TLess '<<<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: 
                    {
                      (DQ 
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: 
                            (command.Simple
                              words: [{<tar>} {<--warning> <Id.Lit_Equals '='>}]
                              redirects: [
                                (redir
                                  op: <Id.Redir_GreatAnd '2>&'>
                                  loc: (redir_loc.Fd fd:2)
                                  arg: {<1>}
                                )
                              ]
                              more_env: [(env_pair name:LC_ALL val:{<C>} spids:[788])]
                              do_fork: T
                            )
                        )
                      )
                    }
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: __tar_last_char
      body: 
        (BraceGroup
          children: [
            (C {<echo>} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Number 1>
                    suffix_op: 
                      (suffix_op.Slice
                        begin: 
                          {
                            (word_part.ArithSub
                              anode: 
                                (arith_expr.Binary
                                  op_id: Id.Arith_Minus
                                  left: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Number 1>
                                        prefix_op: (Id.VSub_Pound)
                                      )
                                    }
                                  right: {<Id.Lit_Digits 1>}
                                )
                            )
                          }
                      )
                  )
                )
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: __tar_parse_old_opt
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<first_word>} {<char>})
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.LogicalAnd
                      left: 
                        (bool_expr.Binary
                          op_id: Id.BoolBinary_eq
                          left: {(DQ ($ Id.VSub_DollarName '$cword'))}
                          right: {<1>}
                        )
                      right: 
                        (bool_expr.LogicalAnd
                          left: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_n
                              child: {(DQ ($ Id.VSub_DollarName '$cur'))}
                            )
                          right: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobNEqual
                              left: 
                                {
                                  (DQ 
                                    (braced_var_sub
                                      token: <Id.VSub_Name cur>
                                      suffix_op: 
                                        (suffix_op.Slice
                                          begin: {<Id.Lit_Digits 0>}
                                          length: {<Id.Lit_Digits 1>}
                                        )
                                    )
                                  )
                                }
                              right: {(SQ <->)}
                            )
                        )
                    )
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:old_opt_progress)
                      op: assign_op.Equal
                      rhs: {<1>}
                      spids: [902]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:first_word)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name words>
                        bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 1>})
                      )
                    }
                  spids: [911]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.LogicalAnd
                      left: 
                        (bool_expr.Unary
                          op_id: Id.BoolUnary_n
                          child: {(DQ ($ Id.VSub_DollarName '$first_word'))}
                        )
                      right: 
                        (bool_expr.Binary
                          op_id: Id.BoolBinary_GlobNEqual
                          left: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name first_word>
                                  suffix_op: 
                                    (suffix_op.Slice
                                      begin: {<Id.Lit_Digits 0>}
                                      length: {<Id.Lit_Digits 1>}
                                    )
                                )
                              )
                            }
                          right: {(DQ <->)}
                        )
                    )
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:old_opt_used)
                      op: assign_op.Equal
                      rhs: {<1>}
                      spids: [952]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_eq
                                  left: {($ Id.VSub_DollarName '$old_opt_used')}
                                  right: {<1>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:char)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <Id.VSub_Name first_word>
                                suffix_op: 
                                  (suffix_op.Slice
                                    begin: {<Id.Lit_Digits 0>}
                                    length: {<Id.Lit_Digits 1>}
                                  )
                              )
                            }
                          spids: [981]
                        )
                      ]
                    )
                    (command.WhileUntil
                      keyword: <Id.KW_While while>
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_n
                                      child: {(DQ ($ Id.VSub_DollarName '$char'))}
                                    )
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      body: 
                        (command.DoGroup
                          children: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<__tar_is_argreq>} {(DQ ($ Id.VSub_DollarName '$char'))})
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:old_opt_parsed)
                                          op: assign_op.PlusEqual
                                          rhs: 
                                            {
                                              (sh_array_literal
                                                left: <Id.Op_LParen _>
                                                words: [{(DQ ($ Id.VSub_DollarName '$char'))}]
                                              )
                                            }
                                          spids: [1019]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [1007 1016]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:first_word)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name first_word>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            tok: <Id.VOp1_DPound '##'>
                                            arg_word: {($ Id.VSub_DollarName '$char')}
                                          )
                                      )
                                    }
                                  spids: [1030]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:char)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name first_word>
                                        suffix_op: 
                                          (suffix_op.Slice
                                            begin: {<Id.Lit_Digits 0>}
                                            length: {<Id.Lit_Digits 1>}
                                          )
                                      )
                                    }
                                  spids: [1038]
                                )
                              ]
                            )
                          ]
                        )
                    )
                  ]
                  spids: [965 978]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: __tar_preparse_cmdline
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<first_arg>} {<my_args>} {<tmparg>} {<i>} 
              {<Id.Lit_VarLike 'modes='> (DQ <ctxurdA>)}
            )
            (C {<shift>})
            (C {<__tar_parse_old_opt>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:first_arg)
                  op: assign_op.Equal
                  rhs: {<1>}
                  spids: [1095]
                )
              ]
            )
            (command.ForEach
              iter_name: i
              iter_words: [{(DQ ($ Id.VSub_At '$@'))}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName '$i'))}
                      arms: [
                        (case_arm
                          pat_list: [{<--delete>} {<--test-label>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:tar_mode)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name i>
                                        suffix_op: 
                                          (suffix_op.Slice
                                            begin: {<Id.Lit_Digits 2>}
                                            length: {<Id.Lit_Digits 100>}
                                          )
                                      )
                                    }
                                  spids: [1128]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:tar_mode_arg)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName '$i')}
                                  spids: [1138]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [1122 1125 1145 -1]
                        )
                        (case_arm
                          pat_list: [{<--> <Id.Lit_Star '*'>}]
                          spids: [1148 1150 1157 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<-> <Id.Lit_Star '*'> <Id.Lit_LBracket '['> 
                              ($ Id.VSub_DollarName '$modes') <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>
                            }
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:tar_mode)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name i>
                                        suffix_op: 
                                          (suffix_op.PatSub
                                            pat: {<'[^'> ($ Id.VSub_DollarName '$modes') <']'>}
                                            replace: {}
                                            replace_mode: Id.Lit_Slash
                                          )
                                      )
                                    }
                                  spids: [1169]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:tar_mode)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name tar_mode>
                                        suffix_op: 
                                          (suffix_op.Slice
                                            begin: {<Id.Lit_Digits 0>}
                                            length: {<Id.Lit_Digits 1>}
                                          )
                                      )
                                    }
                                  spids: [1181]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:tar_mode_arg)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName '$i')}
                                  spids: [1191]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [1160 1166 1198 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<Id.Lit_Star '*'> <Id.Lit_LBracket '['> ($ Id.VSub_DollarName '$modes') 
                              <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>
                            }
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_eq
                                                  left: {($ Id.VSub_DollarName '$first_arg')}
                                                  right: {<1>}
                                                )
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:tar_mode)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (braced_var_sub
                                                token: <Id.VSub_Name i>
                                                suffix_op: 
                                                  (suffix_op.PatSub
                                                    pat: 
                                                      {<'[^'> ($ Id.VSub_DollarName '$modes') <']'>}
                                                    replace: {}
                                                    replace_mode: Id.Lit_Slash
                                                  )
                                              )
                                            }
                                          spids: [1229]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:tar_mode)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (braced_var_sub
                                                token: <Id.VSub_Name tar_mode>
                                                suffix_op: 
                                                  (suffix_op.Slice
                                                    begin: {<Id.Lit_Digits 0>}
                                                    length: {<Id.Lit_Digits 1>}
                                                  )
                                              )
                                            }
                                          spids: [1241]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:tar_mode_arg)
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_DollarName '$i')}
                                          spids: [1251]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [1213 1226]
                                )
                              ]
                            )
                          ]
                          spids: [1201 1206 1258 -1]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:first_arg)
                          op: assign_op.Equal
                          rhs: {<0>}
                          spids: [1264]
                        )
                      ]
                    )
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: __tar_file_option
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'ext='> (DQ ($ Id.VSub_Number '$1'))})
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$tar_mode'))}
              arms: [
                (case_arm
                  pat_list: [{<c>}]
                  action: [(C {<_filedir>} {<-d>})]
                  spids: [1302 1303 1315 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [(C {<_filedir>} {(DQ ($ Id.VSub_DollarName '$ext'))})]
                  spids: [1318 1319 1329 -1]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: __tar_is_argreq
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<opt>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:opt)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [1356]
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$opt'))}
              arms: [
                (case_arm
                  pat_list: [
                    {<-> <Id.Lit_LBracket '['> <A-Za-z0-9> <Id.Lit_QMark '?'> <Id.Lit_RBracket ']'>}
                  ]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_EqualTilde
                              left: {(DQ ($ Id.VSub_DollarName '$short_arg_req'))}
                              right: 
                                {
                                  (braced_var_sub
                                    token: <Id.VSub_Name opt>
                                    suffix_op: 
                                      (suffix_op.Unary
                                        tok: <Id.VOp1_DPound '##'>
                                        arg_word: {<->}
                                      )
                                  )
                                }
                            )
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                    )
                  ]
                  spids: [1369 1374 1400 -1]
                )
                (case_arm
                  pat_list: [
                    {<Id.Lit_LBracket '['> <A-Za-z0-9> <Id.Lit_QMark '?'> <Id.Lit_RBracket ']'>}
                  ]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_EqualTilde
                              left: {(DQ ($ Id.VSub_DollarName '$short_arg_req'))}
                              right: {(${ Id.VSub_Name opt)}
                            )
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                    )
                  ]
                  spids: [1403 1407 1431 -1]
                )
                (case_arm
                  pat_list: [{<--> <Id.Lit_Star '*'>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_EqualTilde
                              left: {(DQ ($ Id.VSub_DollarName '$long_arg_req'))}
                              right: 
                                {<Id.Lit_Other '['> <Id.Lit_Other '['> <Id.Lit_Other ':'> <blank> 
                                  <Id.Lit_Other ':'> <Id.Lit_Other ']'> <Id.Lit_Other ']'> ($ Id.VSub_DollarName '$opt') <Id.Lit_Other '='> <Id.Lit_Other '['> 
                                  <Id.Lit_Other '['> <Id.Lit_Other ':'> <blank> <Id.Lit_Other ':'> <Id.Lit_Other ']'> <Id.Lit_Other ']'>
                                }
                            )
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                    )
                  ]
                  spids: [1434 1436 1473 -1]
                )
              ]
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<1>})
          ]
        )
    )
    (command.ShFunction
      name: __tar_complete_mode
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<short_modes>} {<has_mode>} {<rawopt>} {<generated>} {<allshort_raw_unused>} 
              {<allshort_raw>} {<filler>} {<i>}
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:short_modes)
                  op: assign_op.Equal
                  rhs: {(DQ <ctx>)}
                  spids: [1522]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Unary
                      op_id: Id.BoolUnary_z
                      child: {(DQ ($ Id.VSub_DollarName '$basic_tar'))}
                    )
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:short_modes)
                      op: assign_op.Equal
                      rhs: {(DQ <ctxurdA>)}
                      spids: [1540]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:rawopt)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name cur>
                        suffix_op: (suffix_op.Unary tok:<Id.VOp1_Pound '#'> arg_word:{<->})
                      )
                    }
                  spids: [1551]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:allshort_raw)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name short_opts>
                        suffix_op: 
                          (suffix_op.PatSub
                            pat: {<'[- ]'>}
                            replace: {}
                            replace_mode: Id.Lit_Slash
                          )
                      )
                    }
                  spids: [1564]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {(DQ ($ Id.VSub_DollarName '$tar_mode'))}
                                  right: {<none>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:filler)
                          op: assign_op.Equal
                          rhs: (word.Empty)
                          spids: [1602]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.LogicalAnd
                                          left: 
                                            (bool_expr.Unary
                                              op_id: Id.BoolUnary_z
                                              child: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                            )
                                          right: 
                                            (bool_expr.Unary
                                              op_id: Id.BoolUnary_z
                                              child: {(DQ ($ Id.VSub_DollarName '$basic_tar'))}
                                            )
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:filler)
                                  op: assign_op.Equal
                                  rhs: {<->}
                                  spids: [1629]
                                )
                              ]
                            )
                          ]
                          spids: [1605 1626]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:generated)
                          op: assign_op.Equal
                          rhs: {(DQ )}
                          spids: [1637]
                        )
                      ]
                    )
                    (command.ForExpr
                      init: 
                        (arith_expr.BinaryAssign
                          op_id: Id.Arith_Equal
                          left: <Id.Lit_ArithVarLike i>
                          right: {<Id.Lit_Digits 0>}
                        )
                      cond: {<Id.Lit_Digits 1>}
                      update: 
                        (arith_expr.UnaryAssign
                          op_id: Id.Node_PostDPlus
                          child: <Id.Lit_ArithVarLike i>
                        )
                      body: 
                        (command.DoGroup
                          children: [
                            (C {<local>} 
                              {<Id.Lit_VarLike 'c='> 
                                (DQ 
                                  (braced_var_sub
                                    token: <Id.VSub_Name short_modes>
                                    suffix_op: 
                                      (suffix_op.Slice
                                        begin: {($ Id.VSub_DollarName '$i')}
                                        length: {<Id.Lit_Digits 1>}
                                      )
                                  )
                                )
                              }
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_z
                                      child: {(DQ ($ Id.VSub_DollarName '$c'))}
                                    )
                                )
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Break break>
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:generated)
                                  op: assign_op.PlusEqual
                                  rhs: 
                                    {
                                      (DQ <' '> ($ Id.VSub_DollarName '$filler') 
                                        ($ Id.VSub_DollarName '$cur') ($ Id.VSub_DollarName '$c')
                                      )
                                    }
                                  spids: [1694]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:COMPREPLY)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (sh_array_literal
                                left: <Id.Op_LParen _>
                                words: [
                                  {
                                    (command_sub
                                      left_token: <Id.Left_DollarParen '$('>
                                      child: 
                                        (C {<compgen>} {<-W>} {(DQ ($ Id.VSub_DollarName '$generated'))})
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [1707]
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [1579 1594]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_eq
                                      left: {(DQ ($ Id.VSub_DollarName '$old_opt_progress'))}
                                      right: {<0>}
                                    )
                                )
                                (C {<__tar_is_argreq>} 
                                  {
                                    (DQ 
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<__tar_last_char>} {(DQ ($ Id.VSub_DollarName '$cur'))})
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: <Id.Op_LParen _>
                                    words: [{(DQ ($ Id.VSub_DollarName '$cur'))}]
                                  )
                                }
                              spids: [1775]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                    )
                  ]
                  spids: [1741 1772]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:allshort_raw_unused)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name allshort_raw>
                        suffix_op: 
                          (suffix_op.PatSub
                            pat: {<'['> ($ Id.VSub_DollarName '$rawopt') <']'>}
                            replace: {}
                            replace_mode: Id.Lit_Slash
                          )
                      )
                    }
                  spids: [1795]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobNEqual
                                  left: {(DQ ($ Id.VSub_DollarName '$tar_mode'))}
                                  right: {<none>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:allshort_raw_unused)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <Id.VSub_Name allshort_raw_unused>
                                suffix_op: 
                                  (suffix_op.PatSub
                                    pat: {<'['> ($ Id.VSub_DollarName '$short_modes') <']'>}
                                    replace_mode: Id.Lit_Slash
                                  )
                              )
                            }
                          spids: [1825]
                        )
                      ]
                    )
                  ]
                  spids: [1807 1822]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:generated)
                  op: assign_op.Equal
                  rhs: (word.Empty)
                  spids: [1840]
                )
              ]
            )
            (command.ForExpr
              init: 
                (arith_expr.BinaryAssign
                  op_id: Id.Arith_Equal
                  left: <Id.Lit_ArithVarLike i>
                  right: {<Id.Lit_Digits 0>}
                )
              cond: {<Id.Lit_Digits 1>}
              update: (arith_expr.UnaryAssign op_id:Id.Node_PostDPlus child:<Id.Lit_ArithVarLike i>)
              body: 
                (command.DoGroup
                  children: [
                    (C {<local>} 
                      {<Id.Lit_VarLike 'c='> 
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name allshort_raw_unused>
                            suffix_op: 
                              (suffix_op.Slice
                                begin: {($ Id.VSub_DollarName '$i')}
                                length: {<Id.Lit_Digits 1>}
                              )
                          )
                        )
                      }
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_z
                              child: {(DQ ($ Id.VSub_DollarName '$c'))}
                            )
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Break break>
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:generated)
                          op: assign_op.PlusEqual
                          rhs: {(DQ <' '> ($ Id.VSub_DollarName '$cur') ($ Id.VSub_DollarName '$c'))}
                          spids: [1895]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (sh_array_literal
                        left: <Id.Op_LParen _>
                        words: [
                          {
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              child: (C {<compgen>} {<-W>} {(DQ ($ Id.VSub_DollarName '$generated'))})
                            )
                          }
                        ]
                      )
                    }
                  spids: [1907]
                )
              ]
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})
          ]
        )
    )
    (command.ShFunction
      name: __gtar_complete_lopts
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<rv>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (sh_array_literal
                        left: <Id.Op_LParen _>
                        words: [
                          {
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              child: 
                                (C {<compgen>} {<-W>} {(DQ ($ Id.VSub_DollarName '$long_opts'))} {<-->} 
                                  {(DQ ($ Id.VSub_DollarName '$cur'))}
                                )
                            )
                          }
                        ]
                      )
                    }
                  spids: [1946]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:rv)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '$?')}
                  spids: [1970]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_GlobDEqual
                      left: {($ Id.VSub_DollarName '$COMPREPLY')}
                      right: {<Id.Lit_Other '*'> <Id.BoolBinary_GlobEqual '='>}
                    )
                )
                (C {<compopt>} {<-o>} {<nospace>})
              ]
            )
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {($ Id.VSub_DollarName '$rv')}
            )
          ]
        )
    )
    (command.ShFunction
      name: __gtar_complete_sopts
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<generated>} {<short_mode_opts>} {<i>} {<c>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:short_mode_opts)
                  op: assign_op.Equal
                  rhs: {(DQ <ctxurdA>)}
                  spids: [2020]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:generated)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name short_opts>
                        suffix_op: 
                          (suffix_op.PatSub
                            pat: {<'['> ($ Id.VSub_DollarName '$short_mode_opts') <']'>}
                            replace: {}
                            replace_mode: Id.Lit_Slash
                          )
                      )
                    }
                  spids: [2026]
                )
              ]
            )
            (command.ForExpr
              init: 
                (arith_expr.BinaryAssign
                  op_id: Id.Arith_Equal
                  left: <Id.Lit_ArithVarLike i>
                  right: {<Id.Lit_Digits 0>}
                )
              cond: {<Id.Lit_Digits 1>}
              update: (arith_expr.UnaryAssign op_id:Id.Node_PostDPlus child:<Id.Lit_ArithVarLike i>)
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:c)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name allshort_raw_unused>
                                  suffix_op: 
                                    (suffix_op.Slice
                                      begin: {($ Id.VSub_DollarName '$i')}
                                      length: {<Id.Lit_Digits 1>}
                                    )
                                )
                              )
                            }
                          spids: [2062]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_z
                              child: {(DQ ($ Id.VSub_DollarName '$c'))}
                            )
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Break break>
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:generated)
                          op: assign_op.PlusEqual
                          rhs: {(DQ <' '> ($ Id.VSub_DollarName '$cur') ($ Id.VSub_DollarName '$c'))}
                          spids: [2089]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (sh_array_literal
                        left: <Id.Op_LParen _>
                        words: [
                          {
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              child: 
                                (C {<compgen>} {<-W>} {(DQ ($ Id.VSub_DollarName '$generated'))} {<-->} 
                                  {(DQ ($ Id.VSub_DollarName '$cur'))}
                                )
                            )
                          }
                        ]
                      )
                    }
                  spids: [2101]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: __tar_try_mode
      body: 
        (BraceGroup
          children: [
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$cur'))}
              arms: [
                (case_arm
                  pat_list: [{<--> <Id.Lit_Star '*'>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_n
                              child: {(DQ ($ Id.VSub_DollarName '$basic_tar'))}
                            )
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                    )
                    (C {<__gtar_complete_lopts>})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {($ Id.VSub_QMark '$?')}
                    )
                  ]
                  spids: [2144 2146 2178 -1]
                )
                (case_arm
                  pat_list: [{<-> <Id.Lit_Star '*'>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_n
                              child: {(DQ ($ Id.VSub_DollarName '$basic_tar'))}
                            )
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<__tar_complete_mode>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                    )
                  ]
                  spids: [2182 2184 2218 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.LogicalOr
                                          left: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_eq
                                              left: {(DQ ($ Id.VSub_DollarName '$cword'))}
                                              right: {<1>}
                                            )
                                          right: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: {(DQ ($ Id.VSub_DollarName '$tar_mode'))}
                                              right: {<none>}
                                            )
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<__tar_complete_mode>})
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Return return>
                                  arg_word: {<0>}
                                )
                              ]
                            )
                          ]
                          spids: [2226 2251]
                        )
                      ]
                    )
                  ]
                  spids: [2222 2223 2266 -1]
                )
              ]
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<1>})
          ]
        )
    )
    (command.ShFunction
      name: __tar_adjust_PREV_from_old_option
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.LogicalAnd
                                  left: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_eq
                                      left: {(DQ ($ Id.VSub_DollarName '$old_opt_used'))}
                                      right: {<1>}
                                    )
                                  right: 
                                    (bool_expr.LogicalAnd
                                      left: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_gt
                                          left: {(DQ ($ Id.VSub_DollarName '$cword'))}
                                          right: {<1>}
                                        )
                                      right: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_lt
                                          left: {(DQ ($ Id.VSub_DollarName '$cword'))}
                                          right: 
                                            {
                                              (word_part.ArithSub
                                                anode: 
                                                  (arith_expr.Binary
                                                    op_id: Id.Arith_Plus
                                                    left: 
                                                      {
                                                        (braced_var_sub
                                                          token: <Id.VSub_Name old_opt_parsed>
                                                          prefix_op: (Id.VSub_Pound)
                                                          bracket_op: 
                                                            (bracket_op.WholeArray
                                                              op_id: Id.Lit_At
                                                            )
                                                        )
                                                      }
                                                    right: {<Id.Lit_Digits 2>}
                                                  )
                                              )
                                            }
                                        )
                                    )
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:prev)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ <-> 
                                (braced_var_sub
                                  token: <Id.VSub_Name old_opt_parsed>
                                  bracket_op: 
                                    (bracket_op.ArrayIndex
                                      expr: 
                                        (arith_expr.Binary
                                          op_id: Id.Arith_Minus
                                          left: {($ Id.VSub_DollarName '$cword')}
                                          right: {<Id.Lit_Digits 2>}
                                        )
                                    )
                                )
                              )
                            }
                          spids: [2359]
                        )
                      ]
                    )
                  ]
                  spids: [2299 2352]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: __tar_extract_like_mode
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<i>})
            (command.ForEach
              iter_name: i
              iter_words: [{<x>} {<d>} {<t>} {<delete>}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {(DQ ($ Id.VSub_DollarName '$tar_mode'))}
                              right: {(DQ ($ Id.VSub_DollarName '$i'))}
                            )
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<1>})
          ]
        )
    )
    (command.ShFunction
      name: __tar_try_list_archive
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<tarball>} {<tarbin>} {<untar>})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<__tar_extract_like_mode>})
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<1>}
                )
              ]
            )
            (C {<set>} {<-->} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name words>
                    bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                  )
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:tarbin)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [2495]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:untar)
                  op: assign_op.Equal
                  rhs: {(DQ <tf>)}
                  spids: [2499]
                )
              ]
            )
            (C {<shift>})
            (command.Simple
              words: [{<read>} {<tarball>}]
              redirects: [
                (redir
                  op: <Id.Redir_TLess '<<<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: 
                    {
                      (DQ 
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: 
                            (command.Pipeline
                              children: [
                                (C {<printf>} {<-->} {(SQ <'%s\\n'>)} {(DQ ($ Id.VSub_At '$@'))})
                                (C {<sed>} {<-n>} 
                                  {
                                    (DQ <'/^.'> <Id.Lit_BadBackslash '\\'> <'{1,'> 
                                      <Id.Lit_BadBackslash '\\'> <'}'> ($ Id.VSub_DollarName '$regex') (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'/p'>
                                    )
                                  }
                                )
                                (C {<tee>} {<'/tmp/jetel'>})
                              ]
                              negated: F
                            )
                        )
                      )
                    }
                )
              ]
              do_fork: T
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_n
                                  child: {(DQ ($ Id.VSub_DollarName '$tarball'))}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<local>} 
                      {<Id.Lit_VarLike 'IFS='> 
                        (single_quoted
                          left: <Id.Left_DollarSingleQuote '$\''>
                          tokens: [<Id.Char_OneChar '\\n'>]
                          multiline: F
                        )
                      }
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:COMPREPLY)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (sh_array_literal
                                left: <Id.Op_LParen _>
                                words: [
                                  {
                                    (command_sub
                                      left_token: <Id.Left_DollarParen '$('>
                                      child: 
                                        (C {<compgen>} {<-o>} {<filenames>} {<-W>} 
                                          {
                                            (DQ 
                                              (command_sub
                                                left_token: <Id.Left_DollarParen '$('>
                                                child: 
                                                  (command.WhileUntil
                                                    keyword: <Id.KW_While while>
                                                    cond: 
                                                      (condition.Shell
                                                        commands: [
                                                          (command.Sentence
                                                            child: (C {<read>} {<line>})
                                                            terminator: <Id.Op_Semi _>
                                                          )
                                                        ]
                                                      )
                                                    body: 
                                                      (command.DoGroup
                                                        children: [
                                                          (C {<printf>} 
                                                            {
                                                              (DQ <'%q'> <Id.Lit_BadBackslash '\\'> <n>)
                                                            } 
                                                            {
                                                              (DQ 
                                                                (command_sub
                                                                  left_token: 
                                                                    <Id.Left_DollarParen '$('>
                                                                  child: 
                                                                    (C {<printf>} 
                                                                      {<Id.Lit_Other '%'> <q> 
                                                                        (DQ 
                                                                          <Id.Lit_BadBackslash '\\'> <n>
                                                                        )
                                                                      } {(DQ ($ Id.VSub_DollarName '$line'))}
                                                                    )
                                                                )
                                                              )
                                                            }
                                                          )
                                                        ]
                                                      )
                                                    redirects: [
                                                      (redir
                                                        op: <Id.Redir_TLess '<<<'>
                                                        loc: (redir_loc.Fd fd:0)
                                                        arg: 
                                                          {
                                                            (DQ 
                                                              (command_sub
                                                                left_token: 
                                                                  <Id.Left_DollarParen '$('>
                                                                child: 
                                                                  (command.Simple
                                                                    words: [
                                                                      {
                                                                        ($ Id.VSub_DollarName 
'$tarbin'
                                                                        )
                                                                      }
                                                                      {
                                                                        ($ Id.VSub_DollarName 
'$untar'
                                                                        )
                                                                      }
                                                                      {
                                                                        (DQ 
                                                                          ($ Id.VSub_DollarName 
'$tarball'
                                                                          )
                                                                        )
                                                                      }
                                                                    ]
                                                                    redirects: [
                                                                      (redir
                                                                        op: <Id.Redir_Great '2>'>
                                                                        loc: (redir_loc.Fd fd:2)
                                                                        arg: {<'/dev/null'>}
                                                                      )
                                                                    ]
                                                                    do_fork: T
                                                                  )
                                                              )
                                                            )
                                                          }
                                                      )
                                                    ]
                                                  )
                                              )
                                            )
                                          } {<-->} 
                                          {
                                            (DQ 
                                              (command_sub
                                                left_token: <Id.Left_DollarParen '$('>
                                                child: 
                                                  (C {<printf>} 
                                                    {(DQ <'%q'> <Id.Lit_BadBackslash '\\'> <n>)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                  )
                                              )
                                            )
                                          }
                                        )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [2580]
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [2556 2569]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: __tar_cleanup_prev
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_EqualTilde
                                  left: {(DQ ($ Id.VSub_DollarName '$prev'))}
                                  right: 
                                    {<Id.Lit_Other '^'> <-> <Id.Lit_Other '['> <a-zA-Z0-9> 
                                      <Id.Lit_Other '?'> <Id.Lit_Other ']'> <Id.Lit_Other '*'> <Id.Lit_Other '$'>
                                    }
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:prev)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ <-> 
                                (command_sub
                                  left_token: <Id.Left_DollarParen '$('>
                                  child: (C {<__tar_last_char>} {(DQ ($ Id.VSub_DollarName '$prev'))})
                                )
                              )
                            }
                          spids: [2720]
                        )
                      ]
                    )
                  ]
                  spids: [2691 2713]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: __tar_detect_ext
      body: 
        (BraceGroup
          children: [
            (C {<local>} 
              {<Id.Lit_VarLike 'tars='> 
                (SQ <'@(@(tar|gem|spkg)?(.@(Z|[bgx]z|bz2|lz?(ma)))|t@([abglx]z|b?(z)2))'>)
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:ext)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$tars'))}
                  spids: [2753]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:regex)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (SQ 
                        <
'\\(\\(tar\\|gem\\|spkg\\)\\(\\.\\(Z\\|[bgx]z\\|bz2\\|lz\\(ma\\)\\?\\)\\)\\?\\|t\\([abglx]z\\|bz\\?2\\)\\)'
                        >
                      )
                    }
                  spids: [2759]
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$tar_mode_arg'))}
              arms: [
                (case_arm
                  pat_list: [{<--> <Id.Lit_Star '*'>}]
                  spids: [2775 2777 2784 -1]
                )
                (case_arm
                  pat_list: [
                    {(word_part.ExtGlob op:<Id.ExtGlob_QMark '?('> arms:[{<->}]) <Id.Lit_Star '*'> 
                      <Id.Lit_LBracket '['> <cr> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'> <f>
                    }
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:ext)
                          op: assign_op.Equal
                          rhs: {(SQ <'@(tar|gem|spkg)'>)}
                          spids: [2799]
                        )
                      ]
                    )
                    (command.Case
                      to_match: 
                        {
                          (braced_var_sub
                            token: <Id.VSub_Name words>
                            bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 1>})
                          )
                        }
                      arms: [
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'> <a> <Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:ext)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName '$tars'))}
                                  spids: [2822]
                                )
                              ]
                            )
                          ]
                          spids: [2817 2820 2827 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'> <z> <Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:ext)
                                  op: assign_op.Equal
                                  rhs: {(SQ <'t?(ar.)gz'>)}
                                  spids: [2835]
                                )
                              ]
                            )
                          ]
                          spids: [2830 2833 2840 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'> <Z> <Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:ext)
                                  op: assign_op.Equal
                                  rhs: {(SQ <'ta@(r.Z|z)'>)}
                                  spids: [2848]
                                )
                              ]
                            )
                          ]
                          spids: [2843 2846 2853 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<Id.Lit_Star '*'> <Id.Lit_LBracket '['> <jy> <Id.Lit_RBracket ']'> 
                              <Id.Lit_Star '*'>
                            }
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:ext)
                                  op: assign_op.Equal
                                  rhs: {(SQ <'t@(?(ar.)bz?(2)|b2)'>)}
                                  spids: [2863]
                                )
                              ]
                            )
                          ]
                          spids: [2856 2861 2868 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'> <J> <Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:ext)
                                  op: assign_op.Equal
                                  rhs: {(SQ <'t?(ar.)xz'>)}
                                  spids: [2876]
                                )
                              ]
                            )
                          ]
                          spids: [2871 2874 2881 -1]
                        )
                      ]
                    )
                  ]
                  spids: [2787 2796 2887 -1]
                )
                (case_arm
                  pat_list: [{(word_part.ExtGlob op:<Id.ExtGlob_Plus '+('> arms:[{<'[^ZzJjy]'>}]) <f>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:ext)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$tars'))}
                          spids: [2897]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:regex)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (SQ 
                                <
'\\(\\(tar\\|gem\\|spkg\\)\\(\\.\\(Z\\|[bgx]z\\|bz2\\|lz\\(ma\\)\\?\\)\\)\\?\\|t\\([abglx]z\\|bz\\?2\\)\\)'
                                >
                              )
                            }
                          spids: [2903]
                        )
                      ]
                    )
                  ]
                  spids: [2890 2894 2909 -1]
                )
                (case_arm
                  pat_list: [
                    {<Id.Lit_Star '*'> <Id.Lit_LBracket '['> <Zz> <Id.Lit_RBracket ']'> 
                      <Id.Lit_Star '*'> <f>
                    }
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:ext)
                          op: assign_op.Equal
                          rhs: {(SQ <'@(@(t?(ar.)|gem.|spkg.)@(gz|Z)|taz)'>)}
                          spids: [2921]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:regex)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (SQ 
                                <'\\(\\(t\\(ar\\.\\)\\?\\|gem\\.\\|spkg\\.\\)\\(gz\\|Z\\)\\|taz\\)'>
                              )
                            }
                          spids: [2927]
                        )
                      ]
                    )
                  ]
                  spids: [2912 2918 2933 -1]
                )
                (case_arm
                  pat_list: [
                    {<Id.Lit_Star '*'> <Id.Lit_LBracket '['> <jy> <Id.Lit_RBracket ']'> 
                      <Id.Lit_Star '*'> <f>
                    }
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:ext)
                          op: assign_op.Equal
                          rhs: {(SQ <'@(@(t?(ar.)|gem.)bz?(2)|spkg|tb2)'>)}
                          spids: [2945]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:regex)
                          op: assign_op.Equal
                          rhs: {(SQ <'\\(\\(t\\(ar\\.\\)\\?\\|gem\\.\\)bz2\\?\\|spkg\\|tb2\\)'>)}
                          spids: [2951]
                        )
                      ]
                    )
                  ]
                  spids: [2936 2942 2957 -1]
                )
                (case_arm
                  pat_list: [
                    {<Id.Lit_Star '*'> <Id.Lit_LBracket '['> <J> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'> 
                      <f>
                    }
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:ext)
                          op: assign_op.Equal
                          rhs: {(SQ <'@(@(tar|gem|spkg).@(lzma|xz)|t[lx]z)'>)}
                          spids: [2969]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:regex)
                          op: assign_op.Equal
                          rhs: {(SQ <'\\(\\(tar\\|gem\\|spkg\\)\\.\\(lzma\\|xz\\)\\|t[lx]z\\)'>)}
                          spids: [2975]
                        )
                      ]
                    )
                  ]
                  spids: [2960 2966 2981 -1]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _gtar
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<long_opts>} {<short_opts>} {<long_arg_none>} {<long_arg_opt>} {<long_arg_req>} 
              {<short_arg_none>} {<short_arg_opt>} {<short_arg_req>} {<tar_mode>} {<tar_mode_arg>} 
              {<Id.Lit_VarLike 'old_opt_progress='> <0>} {<Id.Lit_VarLike 'old_opt_used='> <0>} 
              {<Id.Lit_VarLike 'old_opt_parsed='> (sh_array_literal left:<Id.Op_LParen _>)}
            )
            (C {<local>} {<Id.Lit_VarLike 'tar_mode='> <none>})
            (C {<local>} {<Id.Lit_VarLike 'tar_mode_arg='>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {(DQ ($ Id.VSub_DollarName '$_TAR_OPT_DEBUG'))}
                                  right: {<1>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<set>} {<-x>})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:PS4)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                                <'BASH_SOURCE:'> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'LINENO: '>
                              )
                            }
                          spids: [3087]
                        )
                      ]
                    )
                  ]
                  spids: [3064 3079]
                )
              ]
            )
            (C {<local>} {<cur>} {<prev>} {<words>} {<cword>} {<split>})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<_init_completion>} {<-s>})
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (C {<__gnu_tar_parse_help>})
            (C {<__tar_preparse_cmdline>} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name words>
                    bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                  )
                )
              }
            )
            (C {<local>} {<ext>} {<regex>} {<tar>} {<untar>})
            (C {<__tar_detect_ext>})
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [(command.Sentence child:(C {<true>}) terminator:<Id.Op_Semi _>)]
                )
              body: 
                (command.DoGroup
                  children: [
                    (C {<__tar_adjust_PREV_from_old_option>})
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<__tar_posix_prev_handle>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Break break>
                        )
                      ]
                    )
                    (C {<__tar_cleanup_prev>})
                    (command.Case
                      to_match: {($ Id.VSub_DollarName '$prev')}
                      arms: [
                        (case_arm
                          pat_list: [{<-C>} {<--directory>}]
                          action: [
                            (C {<_filedir>} {<-d>})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [3205 3208 3219 -1]
                        )
                        (case_arm
                          pat_list: [{<--atime-preserve>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              child: 
                                                (C {<compgen>} {<-W>} {(SQ <'replace system'>)} {<-->} 
                                                  {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [3226]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [3222 3223 3253 -1]
                        )
                        (case_arm
                          pat_list: [{<--group>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              child: 
                                                (C {<compgen>} {<-g>} {<-->} 
                                                  {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [3260]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [3256 3257 3283 -1]
                        )
                        (case_arm
                          pat_list: [{<--owner>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              child: 
                                                (C {<compgen>} {<-u>} {<-->} 
                                                  {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [3290]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [3286 3287 3313 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<-F>}
                            {<--info-script>}
                            {<--new-volume-script>}
                            {<--rmt-command>}
                            {<--rsh-command>}
                            {<-I>}
                            {<--use-compress-program>}
                          ]
                          action: [
                            (C {<compopt>} {<-o>} {<filenames>})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              child: 
                                                (C {<compgen>} {<-c>} {<-->} 
                                                  {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [3341]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [3316 3331 3364 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<--volno-file>}
                            {<--add-file>}
                            {<-T>}
                            {<--files-from>}
                            {<-X>}
                            {<--exclude-from>}
                            {<--index-file>}
                            {<--listed-incremental>}
                            {<-g>}
                          ]
                          action: [
                            (C {<_filedir>})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [3367 3386 3395 -1]
                        )
                        (case_arm
                          pat_list: [{<-H>} {<--format>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              child: 
                                                (C {<compgen>} {<-W>} 
                                                  {(SQ <'gnu oldgnu pax posix ustar v7'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [3404]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [3398 3401 3433 -1]
                        )
                        (case_arm
                          pat_list: [{<--quoting-style>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              child: 
                                                (C {<compgen>} {<-W>} 
                                                  {
                                                    (SQ <'literal shell shell-always c c-maybe\n'> 
                                                      <'                    escape locale clocale'>
                                                    )
                                                  } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [3440]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [3436 3437 3468 -1]
                        )
                        (case_arm
                          pat_list: [{<--totals>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              child: 
                                                (C {<compgen>} {<-W>} 
                                                  {(SQ <'SIGHUP SIGQUIT SIGINT SIGUSR1 SIGUSR2'>)} {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [3475]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [3471 3472 3504 -1]
                        )
                        (case_arm
                          pat_list: [{<--warning>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              child: 
                                                (C {<compgen>} {<-W>} 
                                                  {
                                                    (DQ 
                                                      (command_sub
                                                        left_token: <Id.Left_DollarParen '$('>
                                                        child: (C {<__gtar_parse_warnings>})
                                                      )
                                                    )
                                                  } {<-->} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [3511]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [3507 3508 3540 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<--file>}
                            {<-f>}
                            {<-> 
                              (word_part.ExtGlob
                                op: <Id.ExtGlob_Bang '!('>
                                arms: [{<-> <Id.Lit_Other '*'>}]
                              ) <f>
                            }
                          ]
                          action: [
                            (C {<__tar_file_option>} {(DQ ($ Id.VSub_DollarName '$ext'))})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [3543 3553 3566 -1]
                        )
                        (case_arm
                          pat_list: [{<--> <Id.Lit_Star '*'>}]
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_EqualTilde
                                      left: {(DQ <' '> ($ Id.VSub_DollarName '$long_arg_req') <' '>)}
                                      right: 
                                        {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\ '>) 
                                          ($ Id.VSub_DollarName '$prev') <Id.Lit_Other '='> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\ '>)
                                        }
                                    )
                                )
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Break break>
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_EqualTilde
                                      left: {(DQ <' '> ($ Id.VSub_DollarName '$long_arg_opt') <' '>)}
                                      right: 
                                        {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\ '>) 
                                          ($ Id.VSub_DollarName '$prev') (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\ '>)
                                        }
                                    )
                                )
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Break break>
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {($ Id.VSub_DollarName '$split')})
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Break break>
                                )
                              ]
                            )
                          ]
                          spids: [3569 3571 3659 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<-> <Id.Lit_LBracket '['> <a-zA-Z0-9> <Id.Lit_QMark '?'> 
                              <Id.Lit_RBracket ']'>
                            }
                          ]
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_EqualTilde
                                      left: {(DQ ($ Id.VSub_DollarName '$short_arg_req'))}
                                      right: 
                                        {
                                          (braced_var_sub
                                            token: <Id.VSub_Name prev>
                                            suffix_op: 
                                              (suffix_op.Unary
                                                tok: <Id.VOp1_DPound '##'>
                                                arg_word: {<->}
                                              )
                                          )
                                        }
                                    )
                                )
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Break break>
                                )
                              ]
                            )
                          ]
                          spids: [3662 3667 3695 -1]
                        )
                      ]
                    )
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName '$cur'))}
                      arms: [
                        (case_arm
                          pat_list: [
                            {<-> <Id.Lit_LBracket '['> <a-zA-Z0-9> <Id.Lit_ArrayLhsClose ']='> 
                              <Id.Lit_Star '*'>
                            }
                          ]
                          action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                          spids: [3715 3720 3730 -1]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<__tar_try_mode>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Break break>
                        )
                      ]
                    )
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName '$cur'))}
                      arms: [
                        (case_arm
                          pat_list: [{<--> <Id.Lit_Star '*'>}]
                          action: [
                            (C {<__gtar_complete_lopts>})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [3766 3768 3777 -1]
                        )
                        (case_arm
                          pat_list: [{<-> <Id.Lit_Star '*'>}]
                          action: [
                            (C {<__gtar_complete_sopts>})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [3780 3782 3795 -1]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_eq
                              left: {(DQ ($ Id.VSub_DollarName '$cword'))}
                              right: {<1>}
                            )
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Break break>
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<__tar_try_list_archive>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Break break>
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobNEqual
                                          left: {($ Id.VSub_DollarName '$tar_mode')}
                                          right: {<none>}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<_filedir>})]
                          spids: [3840 3853]
                        )
                      ]
                    )
                    (command.ControlFlow token:<Id.ControlFlow_Break break>)
                  ]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {(DQ ($ Id.VSub_DollarName '$_TAR_OPT_DEBUG'))}
                                  right: {<1>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<set>} {<Id.Lit_Other '+'> <x>}) (C {<unset>} {<PS4>})]
                  spids: [3873 3888]
                )
              ]
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})
          ]
        )
    )
    (command.ShFunction
      name: __tar_posix_prev_handle
      body: 
        (BraceGroup
          children: [
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$prev'))}
              arms: [
                (case_arm
                  pat_list: [{<-f>}]
                  action: [
                    (C {<__tar_file_option>} {(DQ ($ Id.VSub_DollarName '$ext'))})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [3930 3931 3946 -1]
                )
                (case_arm
                  pat_list: [{<-b>}]
                  action: [(command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})]
                  spids: [3949 3950 -1 3958]
                )
              ]
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<1>})
          ]
        )
    )
    (command.ShFunction
      name: _posix_tar
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<long_opts>} {<short_opts>} {<basic_tar>} {<long_arg_none>} {<long_arg_opt>} 
              {<long_arg_req>} {<short_arg_none>} {<short_arg_opt>} {<short_arg_req>} {<tar_mode>} {<tar_mode_arg>} 
              {<Id.Lit_VarLike 'old_opt_progress='> <0>} {<Id.Lit_VarLike 'old_opt_used='> <1>} 
              {<Id.Lit_VarLike 'old_opt_parsed='> (sh_array_literal left:<Id.Op_LParen _>)}
            )
            (C {<local>} {<Id.Lit_VarLike 'tar_mode='> <none>})
            (C {<local>} {<Id.Lit_VarLike 'tar_mode_arg='>})
            (C {<local>} {<cur>} {<prev>} {<words>} {<cword>} {<split>})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<_init_completion>} {<-s>})
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:basic_tar)
                  op: assign_op.Equal
                  rhs: {<yes>}
                  spids: [4066]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:tar_mode)
                  op: assign_op.Equal
                  rhs: {<none>}
                  spids: [4070]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:short_arg_req)
                  op: assign_op.Equal
                  rhs: {(DQ <fb>)}
                  spids: [4083]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:short_arg_none)
                  op: assign_op.Equal
                  rhs: {(DQ <wmv>)}
                  spids: [4089]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:short_opts)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ ($ Id.VSub_DollarName '$short_arg_req') 
                        ($ Id.VSub_DollarName '$short_arg_none')
                      )
                    }
                  spids: [4095]
                )
              ]
            )
            (C {<__tar_preparse_cmdline>} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name words>
                    bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                  )
                )
              }
            )
            (C {<local>} {<ext>} {<regex>} {<tar>} {<untar>})
            (C {<__tar_detect_ext>})
            (C {<__tar_adjust_PREV_from_old_option>})
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<__tar_posix_prev_handle>})
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<0>}
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<__tar_try_mode>})
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<__tar_try_list_archive>})
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (C {<_filedir>})
          ]
        )
    )
    (command.ShFunction
      name: _tar
      body: 
        (BraceGroup
          children: [
            (C {<local>} 
              {<Id.Lit_VarLike 'cmd='> 
                (braced_var_sub
                  token: <Id.VSub_Name COMP_WORDS>
                  bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 0>})
                )
              } {<output>} {<line>}
            )
            (command.Simple
              words: [{<read>} {<line>}]
              redirects: [
                (redir
                  op: <Id.Redir_TLess '<<<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: 
                    {
                      (DQ 
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: (C {($ Id.VSub_DollarName '$cmd')} {<--version>})
                        )
                      )
                    }
                )
              ]
              do_fork: T
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$line'))}
              arms: [
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'> <GNU> <Id.Lit_Star '*'>}]
                  action: [(C {<_gtar>} {(DQ ($ Id.VSub_At '$@'))})]
                  spids: [4217 4220 4230 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [(C {<_posix_tar>} {(DQ ($ Id.VSub_At '$@'))})]
                  spids: [4233 4234 4244 -1]
                )
              ]
            )
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} {<-n>} 
                      {
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name COMP_TAR_INTERNAL_PATHS>
                            suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:(word.Empty))
                          )
                        )
                      } {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (C {<complete>} {<-F>} {<_tar>} {<-o>} {<dirnames>} {<tar>})
            (C {<complete>} {<-F>} {<_gtar>} {<-o>} {<dirnames>} {<gtar>})
            (C {<complete>} {<-F>} {<_posix_tar>} {<-o>} {<dirnames>} {<bsdtar>})
            (C {<complete>} {<-F>} {<_posix_tar>} {<-o>} {<dirnames>} {<star>})
          ]
          spids: [4253 4269]
        )
      ]
      else_action: [
        (C {<complete>} {<-F>} {<_tar>} {<tar>})
        (C {<complete>} {<-F>} {<_gtar>} {<gtar>})
        (C {<complete>} {<-F>} {<_posix_tar>} {<bsdtar>})
        (C {<complete>} {<-F>} {<_posix_tar>} {<star>})
      ]
    )
  ]
)