(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:USAGE)
          op: Equal
          rhs: 
            {
              (SQ 
                <
'[-n [<num>]] -l [<pattern>] | [-a | -s | -u <key-id>] [-f | -d | -v] [-m <msg>] <tagname> [<head>]'
                >
              )
            }
          spids: [7]
        )
      ]
      spids: [7]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:SUBDIRECTORY_OK) op:Equal rhs:{(SQ <Yes>)} spids:[12])]
      spids: [12]
    )
    (C {(.)} {(git-sh-setup)})
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:message_given) op:Equal rhs:{(EmptyPart)} spids:[22])]
      spids: [22]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:annotate) op:Equal rhs:{(EmptyPart)} spids:[24])]
      spids: [24]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:signed) op:Equal rhs:{(EmptyPart)} spids:[26])]
      spids: [26]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:force) op:Equal rhs:{(EmptyPart)} spids:[28])]
      spids: [28]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:message) op:Equal rhs:{(EmptyPart)} spids:[30])]
      spids: [30]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:username) op:Equal rhs:{(EmptyPart)} spids:[32])]
      spids: [32]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:list) op:Equal rhs:{(EmptyPart)} spids:[34])]
      spids: [34]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:verify) op:Equal rhs:{(EmptyPart)} spids:[36])]
      spids: [36]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:LINES) op:Equal rhs:{(0)} spids:[38])]
      spids: [38]
    )
    (While
      cond: [(C {(test)} {($ VSub_Pound '$#')} {(KW_Bang '!') (Lit_Other '=')} {(0)})]
      body: 
        (DoGroup
          children: [
            (Case
              to_match: {(DQ ($ VSub_Number '$1'))}
              arms: [
                (case_arm
                  pat_list: [{(-a)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:annotate) op:Equal rhs:{(1)} spids:[68])]
                      spids: [68]
                    )
                    (C {(shift)})
                  ]
                  spids: [64 65 75 16777215]
                )
                (case_arm
                  pat_list: [{(-s)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:annotate) op:Equal rhs:{(1)} spids:[82])]
                      spids: [82]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:signed) op:Equal rhs:{(1)} spids:[86])]
                      spids: [86]
                    )
                    (C {(shift)})
                  ]
                  spids: [78 79 93 16777215]
                )
                (case_arm
                  pat_list: [{(-f)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:force) op:Equal rhs:{(1)} spids:[100])]
                      spids: [100]
                    )
                    (C {(shift)})
                  ]
                  spids: [96 97 107 16777215]
                )
                (case_arm
                  pat_list: [{(-n)}]
                  action: [
                    (Case
                      to_match: {(DQ ($ VSub_Pound '$#') (',') ($ VSub_Number '$2'))}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(1) (Lit_Comma ',') (Lit_Other '*')}
                            {(Lit_Other '*') (Lit_Comma ',') (-) (Lit_Other '*')}
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:LINES)
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [138]
                                )
                              ]
                              spids: [138]
                            )
                          ]
                          spids: [125 135 145 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [
                            (C {(shift)})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:LINES)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(expr)} {(DQ ($ VSub_Number '$1'))} {(Lit_Other ':')} 
                                                {(SQ <'\\([0-9]*\\)'>)}
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [155 167]
                                      )
                                    }
                                  spids: [154]
                                )
                              ]
                              spids: [154]
                            )
                            (AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(Lit_Other '[')} {(-z)} {(DQ ($ VSub_Name '$LINES'))} 
                                  {(Lit_Other ']')}
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:LINES)
                                      op: Equal
                                      rhs: {(1)}
                                      spids: [182]
                                    )
                                  ]
                                  spids: [182]
                                )
                              ]
                            )
                          ]
                          spids: [148 149 189 16777215]
                        )
                      ]
                      spids: [114 122 192]
                    )
                    (C {(shift)})
                  ]
                  spids: [110 111 198 16777215]
                )
                (case_arm
                  pat_list: [{(-l)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:list) op:Equal rhs:{(1)} spids:[205])]
                      spids: [205]
                    )
                    (C {(shift)})
                    (Case
                      to_match: {($ VSub_Pound '$#')}
                      arms: [
                        (case_arm
                          pat_list: [{(0)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:PATTERN)
                                  op: Equal
                                  rhs: {(EmptyPart)}
                                  spids: [222]
                                )
                              ]
                              spids: [222]
                            )
                          ]
                          spids: [219 220 225 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:PATTERN)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number '$1'))}
                                  spids: [232]
                                )
                              ]
                              spids: [232]
                            )
                            (C {(shift)})
                          ]
                          spids: [228 229 244 16777215]
                        )
                      ]
                      spids: [212 216 247]
                    )
                    (Pipeline
                      children: [
                        (C {(git)} {(rev-parse)} {(--symbolic)} {(--tags)})
                        (C {(sort)})
                        (While
                          cond: [(C {(read)} {(TAG)})]
                          body: 
                            (DoGroup
                              children: [
                                (Case
                                  to_match: {(DQ ($ VSub_Name '$TAG'))}
                                  arms: [
                                    (case_arm
                                      pat_list: [
                                        {(Lit_Other '*') ($ VSub_Name '$PATTERN') (Lit_Other '*')}
                                      ]
                                      spids: [284 287 289 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Other '*')}]
                                      action: [(ControlFlow token:<ControlFlow_Continue continue>)]
                                      spids: [292 293 297 16777215]
                                    )
                                  ]
                                  spids: [275 281 300]
                                )
                                (AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(Lit_Other '[')} {(DQ ($ VSub_Name '$LINES'))} {(-le)} {(0)} 
                                      {(Lit_Other ']')}
                                    )
                                    (BraceGroup
                                      children: [
                                        (Sentence
                                          child: (C {(echo)} {(DQ ($ VSub_Name '$TAG'))})
                                          terminator: <Op_Semi ';'>
                                        )
                                        (Sentence
                                          child: (ControlFlow token:<ControlFlow_Continue continue>)
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      spids: [317]
                                    )
                                  ]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:OBJTYPE)
                                      op: Equal
                                      rhs: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (C {(git)} {(cat-file)} {(-t)} 
                                                    {(DQ ($ VSub_Name '$TAG'))}
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub '$('>
                                            spids: [333 343]
                                          )
                                        }
                                      spids: [332]
                                    )
                                  ]
                                  spids: [332]
                                )
                                (Case
                                  to_match: {($ VSub_Name '$OBJTYPE')}
                                  arms: [
                                    (case_arm
                                      pat_list: [{(tag)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:ANNOTATION)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (Pipeline
                                                            children: [
                                                              (C {(git)} {(cat-file)} {(tag)} 
                                                                {(DQ ($ VSub_Name '$TAG'))}
                                                              )
                                                              (C {(sed)} {(-e)} {(SQ <'1,/^$/d'>)})
                                                              (C {(sed)} {(-n)} {(-e)} 
                                                                {
                                                                  (DQ ('\n') 
                                                                    (
'\t\t\t\t\t/^-----BEGIN PGP SIGNATURE-----'
                                                                    ) (EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) ('/q\n') ('\t\t\t\t\t2,') 
                                                                    (EscapedLiteralPart
                                                                      token: <Lit_EscapedChar '\\$'>
                                                                    ) ('s/^/    /\n') ('\t\t\t\t\tp\n') ('\t\t\t\t\t') (${ VSub_Name LINES) ('q\n') ('\t\t\t\t')
                                                                  )
                                                                }
                                                              )
                                                            ]
                                                            negated: F
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_CommandSub '$('>
                                                    spids: [358 405]
                                                  )
                                                }
                                              spids: [357]
                                            )
                                          ]
                                          spids: [357]
                                        )
                                        (C {(printf)} {(DQ ('%-15s %s') (Lit_Other '\\') (n))} 
                                          {(DQ ($ VSub_Name '$TAG'))} {(DQ ($ VSub_Name '$ANNOTATION'))}
                                        )
                                      ]
                                      spids: [353 354 425 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Other '*')}]
                                      action: [(C {(echo)} {(DQ ($ VSub_Name '$TAG'))})]
                                      spids: [428 429 438 16777215]
                                    )
                                  ]
                                  spids: [346 350 441]
                                )
                              ]
                              spids: [272 444]
                            )
                        )
                      ]
                      negated: F
                    )
                  ]
                  spids: [201 202 447 16777215]
                )
                (case_arm
                  pat_list: [{(-m)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:annotate)
                          op: Equal
                          rhs: {(1)}
                          spids: [454]
                        )
                      ]
                      spids: [454]
                    )
                    (C {(shift)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:message)
                          op: Equal
                          rhs: {(DQ ($ VSub_Number '$1'))}
                          spids: [461]
                        )
                      ]
                      spids: [461]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(test)} {(DQ ($ VSub_Pound '$#'))} {(Lit_Other '=')} {(DQ (0))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [(C {(die)} {(DQ ('error: option -m needs an argument'))})]
                          spids: [16777215 482]
                        )
                      ]
                      else_action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:message)
                              op: Equal
                              rhs: {(DQ ($ VSub_Number '$1'))}
                              spids: [495]
                            )
                          ]
                          spids: [495]
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:message_given)
                              op: Equal
                              rhs: {(1)}
                              spids: [501]
                            )
                          ]
                          spids: [501]
                        )
                        (C {(shift)})
                      ]
                      spids: [492 508]
                    )
                  ]
                  spids: [450 451 511 16777215]
                )
                (case_arm
                  pat_list: [{(-F)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:annotate)
                          op: Equal
                          rhs: {(1)}
                          spids: [518]
                        )
                      ]
                      spids: [518]
                    )
                    (C {(shift)})
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(test)} {(DQ ($ VSub_Pound '$#'))} {(Lit_Other '=')} {(DQ (0))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [(C {(die)} {(DQ ('error: option -F needs an argument'))})]
                          spids: [16777215 540]
                        )
                      ]
                      else_action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:message)
                              op: Equal
                              rhs: 
                                {
                                  (DQ 
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [(C {(cat)} {(DQ ($ VSub_Number '$1'))})]
                                        )
                                      left_token: <Left_CommandSub '$('>
                                      spids: [555 561]
                                    )
                                  )
                                }
                              spids: [553]
                            )
                          ]
                          spids: [553]
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:message_given)
                              op: Equal
                              rhs: {(1)}
                              spids: [565]
                            )
                          ]
                          spids: [565]
                        )
                        (C {(shift)})
                      ]
                      spids: [550 572]
                    )
                  ]
                  spids: [514 515 575 16777215]
                )
                (case_arm
                  pat_list: [{(-u)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:annotate)
                          op: Equal
                          rhs: {(1)}
                          spids: [582]
                        )
                      ]
                      spids: [582]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:signed) op:Equal rhs:{(1)} spids:[586])]
                      spids: [586]
                    )
                    (C {(shift)})
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(test)} {(DQ ($ VSub_Pound '$#'))} {(Lit_Other '=')} {(DQ (0))})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [(C {(die)} {(DQ ('error: option -u needs an argument'))})]
                          spids: [16777215 608]
                        )
                      ]
                      else_action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:username)
                              op: Equal
                              rhs: {(DQ ($ VSub_Number '$1'))}
                              spids: [621]
                            )
                          ]
                          spids: [621]
                        )
                        (C {(shift)})
                      ]
                      spids: [618 630]
                    )
                  ]
                  spids: [578 579 633 16777215]
                )
                (case_arm
                  pat_list: [{(-d)}]
                  action: [
                    (C {(shift)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:had_error)
                          op: Equal
                          rhs: {(0)}
                          spids: [643]
                        )
                      ]
                      spids: [643]
                    )
                    (ForEach
                      iter_name: tag
                      do_arg_iter: T
                      body: 
                        (DoGroup
                          children: [
                            (AndOr
                              ops: [Op_DPipe]
                              children: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:cur)
                                      op: Equal
                                      rhs: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (C {(git)} {(show-ref)} {(--verify)} {(--hash)} {(--)} 
                                                    {(DQ (refs/tags/) ($ VSub_Name '$tag'))}
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub '$('>
                                            spids: [656 671]
                                          )
                                        }
                                      spids: [655]
                                    )
                                  ]
                                  spids: [655]
                                )
                                (BraceGroup
                                  children: [
                                    (SimpleCommand
                                      words: [
                                        {(echo)}
                                        {(DQ ('Seriously, what tag are you talking about?'))}
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 16777215
                                          arg_word: {(2)}
                                          spids: [680]
                                        )
                                      ]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:had_error)
                                          op: Equal
                                          rhs: {(1)}
                                          spids: [688]
                                        )
                                      ]
                                      spids: [688]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [675]
                                )
                              ]
                            )
                            (AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(git)} {(update-ref)} {(-m)} {(SQ <'tag: delete'>)} {(-d)} 
                                  {(DQ (refs/tags/) ($ VSub_Name '$tag'))} {(DQ ($ VSub_Name '$cur'))}
                                )
                                (BraceGroup
                                  children: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:had_error)
                                          op: Equal
                                          rhs: {(1)}
                                          spids: [724]
                                        )
                                      ]
                                      spids: [724]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [721]
                                )
                              ]
                            )
                            (C {(echo)} {(DQ ('Deleted tag ') ($ VSub_Name '$tag') (.))})
                          ]
                          spids: [652 743]
                        )
                      spids: [16777215 16777215]
                    )
                    (ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {($ VSub_Name '$had_error')}
                    )
                  ]
                  spids: [636 637 751 16777215]
                )
                (case_arm
                  pat_list: [{(-v)}]
                  action: [
                    (C {(shift)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:tag_name)
                          op: Equal
                          rhs: {(DQ ($ VSub_Number '$1'))}
                          spids: [761]
                        )
                      ]
                      spids: [761]
                    )
                    (AndOr
                      ops: [Op_DPipe]
                      children: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:tag)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(git)} {(show-ref)} {(--verify)} {(--hash)} {(--)} 
                                            {(DQ (refs/tags/) ($ VSub_Name '$tag_name'))}
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [768 783]
                                  )
                                }
                              spids: [767]
                            )
                          ]
                          spids: [767]
                        )
                        (C {(die)} {(DQ ('Seriously, what tag are you talking about?'))})
                      ]
                    )
                    (C {(git-verify-tag)} {(-v)} {(DQ ($ VSub_Name '$tag'))})
                    (ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {($ VSub_QMark '$?')}
                    )
                  ]
                  spids: [754 755 809 16777215]
                )
                (case_arm
                  pat_list: [{(-) (Lit_Other '*')}]
                  action: [(C {(usage)})]
                  spids: [812 814 820 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [(ControlFlow token:<ControlFlow_Break break>)]
                  spids: [823 824 830 16777215]
                )
              ]
              spids: [55 61 833]
            )
          ]
          spids: [52 835]
        )
    )
    (AndOr
      ops: [Op_DAmp]
      children: [
        (C {(Lit_Other '[')} {(-n)} {(DQ ($ VSub_Name '$list'))} {(Lit_Other ']')})
        (ControlFlow token:<ControlFlow_Exit exit> arg_word:{(0)})
      ]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:name)
          op: Equal
          rhs: {(DQ ($ VSub_Number '$1'))}
          spids: [855]
        )
      ]
      spids: [855]
    )
    (AndOr
      ops: [Op_DPipe]
      children: [(C {(Lit_Other '[')} {(DQ ($ VSub_Name '$name'))} {(Lit_Other ']')}) (C {(usage)})]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:prev)
          op: Equal
          rhs: {(0000000000000000000000000000000000000000)}
          spids: [872]
        )
      ]
      spids: [872]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (C {(git)} {(show-ref)} {(--verify)} {(--quiet)} {(--)} 
              {(DQ (refs/tags/) ($ VSub_Name '$name'))}
            )
          ]
          action: [
            (AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$force'))})
                (C {(die)} {(DQ ("tag '") ($ VSub_Name '$name') ("' already exists"))})
              ]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:prev)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(git)} {(rev-parse)} {(DQ (refs/tags/) ($ VSub_Name '$name'))})
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [915 924]
                      )
                    }
                  spids: [914]
                )
              ]
              spids: [914]
            )
          ]
          spids: [16777215 892]
        )
      ]
      spids: [16777215 926]
    )
    (C {(shift)})
    (AndOr
      ops: [Op_DPipe]
      children: [
        (C {(git)} {(check-ref-format)} {(DQ (tags/) ($ VSub_Name '$name'))})
        (C {(die)} {(DQ ("we do not like '") ($ VSub_Name '$name') ("' as a tag name."))})
      ]
    )
    (AndOr
      ops: [Op_DPipe]
      children: [
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:object)
              op: Equal
              rhs: 
                {
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [
                          (C {(git)} {(rev-parse)} {(--verify)} {(--default)} {(HEAD)} 
                            {(DQ ($ VSub_At '$@'))}
                          )
                        ]
                      )
                    left_token: <Left_CommandSub '$('>
                    spids: [952 966]
                  )
                }
              spids: [951]
            )
          ]
          spids: [951]
        )
        (ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
      ]
    )
    (AndOr
      ops: [Op_DPipe]
      children: [
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:type)
              op: Equal
              rhs: 
                {
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [(C {(git)} {(cat-file)} {(-t)} {($ VSub_Name '$object')})]
                      )
                    left_token: <Left_CommandSub '$('>
                    spids: [975 983]
                  )
                }
              spids: [974]
            )
          ]
          spids: [974]
        )
        (ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
      ]
    )
    (AndOr
      ops: [Op_DPipe]
      children: [
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:tagger)
              op: Equal
              rhs: 
                {
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [(C {(git)} {(var)} {(GIT_COMMITTER_IDENT)})]
                      )
                    left_token: <Left_CommandSub '$('>
                    spids: [992 998]
                  )
                }
              spids: [991]
            )
          ]
          spids: [991]
        )
        (ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
      ]
    )
    (AndOr
      ops: [Op_DPipe Op_DPipe]
      children: [
        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$username'))})
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:username)
              op: Equal
              rhs: 
                {
                  (CommandSubPart
                    command_list: (CommandList children:[(C {(git)} {(config)} {(user.signingkey)})])
                    left_token: <Left_CommandSub '$('>
                    spids: [1019 1025]
                  )
                }
              spids: [1018]
            )
          ]
          spids: [1018]
        )
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:username)
              op: Equal
              rhs: 
                {
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [
                          (C {(expr)} {(DQ (z) ($ VSub_Name '$tagger'))} {(Lit_Other ':')} 
                            {(SQ <'z\\(.*>\\)'>)}
                          )
                        ]
                      )
                    left_token: <Left_CommandSub '$('>
                    spids: [1031 1044]
                  )
                }
              spids: [1030]
            )
          ]
          spids: [1030]
        )
      ]
    )
    (C {(trap)} {(SQ <'rm -f "$GIT_DIR"/TAG_TMP* "$GIT_DIR"/TAG_FINALMSG "$GIT_DIR"/TAG_EDITMSG'>)} 
      {(0)}
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(Lit_Other '[')} {(DQ ($ VSub_Name '$annotate'))} {(Lit_Other ']')})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other '[')} {(-z)} {(DQ ($ VSub_Name '$message_given'))} 
                          {(Lit_Other ']')}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Subshell
                      child: 
                        (CommandList
                          children: [
                            (C {(echo)} {(DQ ('#'))})
                            (C {(echo)} {(DQ ('# Write a tag message'))})
                            (C {(echo)} {(DQ ('#'))})
                          ]
                        )
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$GIT_DIR')) (/TAG_EDITMSG)}
                          spids: [1110]
                        )
                      ]
                      spids: [1086 1108]
                    )
                    (AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(git_editor)} {(DQ ($ VSub_Name '$GIT_DIR')) (/TAG_EDITMSG)})
                        (ControlFlow token:<ControlFlow_Exit exit>)
                      ]
                    )
                  ]
                  spids: [16777215 1083]
                )
              ]
              else_action: [
                (SimpleCommand
                  words: [{(printf)} {(SQ <'%s\\n'>)} {(DQ ($ VSub_Name '$message'))}]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_Name '$GIT_DIR')) (/TAG_EDITMSG)}
                      spids: [1143]
                    )
                  ]
                )
              ]
              spids: [1130 1150]
            )
            (Pipeline
              children: [
                (SimpleCommand
                  words: [{(grep)} {(-v)} {(SQ <'^#'>)}]
                  redirects: [
                    (Redir
                      op_id: Redir_Less
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_Name '$GIT_DIR')) (/TAG_EDITMSG)}
                      spids: [1162]
                    )
                  ]
                )
                (SimpleCommand
                  words: [{(git)} {(stripspace)}]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_Name '$GIT_DIR')) (/TAG_FINALMSG)}
                      spids: [1175]
                    )
                  ]
                )
              ]
              negated: F
            )
            (AndOr
              ops: [Op_DPipe]
              children: [
                (C {(Lit_Other '[')} {(-s)} {(DQ ($ VSub_Name '$GIT_DIR')) (/TAG_FINALMSG)} {(-o)} {(-n)} 
                  {(DQ ($ VSub_Name '$message_given'))} {(Lit_Other ']')}
                )
                (BraceGroup
                  children: [
                    (SimpleCommand
                      words: [{(echo)} {(DQ ('No tag message?'))}]
                      redirects: [
                        (Redir
                          op_id: Redir_GreatAnd
                          fd: 16777215
                          arg_word: {(2)}
                          spids: [1209]
                        )
                      ]
                    )
                    (ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
                  ]
                  spids: [1204]
                )
              ]
            )
            (Subshell
              child: 
                (CommandList
                  children: [
                    (Sentence
                      child: 
                        (C {(printf)} {(SQ <'object %s\\ntype %s\\ntag %s\\ntagger %s\\n\\n'>)} 
                          {(DQ ($ VSub_Name '$object'))} {(DQ ($ VSub_Name '$type'))} {(DQ ($ VSub_Name '$name'))} {(DQ ($ VSub_Name '$tagger'))}
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(cat)} {(DQ ($ VSub_Name '$GIT_DIR')) (/TAG_FINALMSG)})
                  ]
                )
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$GIT_DIR')) (/TAG_TMP)}
                  spids: [1263]
                )
              ]
              spids: [1226 1261]
            )
            (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$GIT_DIR')) (/TAG_TMP.asc)} 
              {(DQ ($ VSub_Name '$GIT_DIR')) (/TAG_FINALMSG)}
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (C {(Lit_Other '[')} {(DQ ($ VSub_Name '$signed'))} {(Lit_Other ']')})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (AndOr
                      ops: [Op_DAmp Op_DPipe]
                      children: [
                        (C {(gpg)} {(-bsa)} {(-u)} {(DQ ($ VSub_Name '$username'))} 
                          {(DQ ($ VSub_Name '$GIT_DIR')) (/TAG_TMP)}
                        )
                        (SimpleCommand
                          words: [{(cat)} {(DQ ($ VSub_Name '$GIT_DIR')) (/TAG_TMP.asc)}]
                          redirects: [
                            (Redir
                              op_id: Redir_DGreat
                              fd: 16777215
                              arg_word: {(DQ ($ VSub_Name '$GIT_DIR')) (/TAG_TMP)}
                              spids: [1324]
                            )
                          ]
                        )
                        (C {(die)} {(DQ ('failed to sign the tag with GPG.'))})
                      ]
                    )
                  ]
                  spids: [16777215 1296]
                )
              ]
              spids: [16777215 1340]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:object)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (SimpleCommand
                                words: [{(git-mktag)}]
                                redirects: [
                                  (Redir
                                    op_id: Redir_Less
                                    fd: 16777215
                                    arg_word: {(DQ ($ VSub_Name '$GIT_DIR')) (/TAG_TMP)}
                                    spids: [1347]
                                  )
                                ]
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1344 1353]
                      )
                    }
                  spids: [1343]
                )
              ]
              spids: [1343]
            )
          ]
          spids: [16777215 1067]
        )
      ]
      spids: [16777215 1355]
    )
    (C {(git)} {(update-ref)} {(DQ (refs/tags/) ($ VSub_Name '$name'))} {(DQ ($ VSub_Name '$object'))} 
      {(DQ ($ VSub_Name '$prev'))}
    )
  ]
)