(command.CommandList
  children: [
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:USAGE spids:[4])
          op: Equal
          rhs: {(SQ <'[help|start|bad|good|new|old|terms|skip|next|reset|visualize|replay|log|run]'>)}
          spids: [4]
        )
      ]
      spids: [4]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:LONG_USAGE spids:[9])
          op: Equal
          rhs: 
            {
              (SQ <'git bisect help\n'> <'\tprint this long help message.\n'> 
                <'git bisect start [--term-{old,good}=<term> --term-{new,bad}=<term>]\n'> <'\t\t [--no-checkout] [<bad> [<good>...]] [--] [<pathspec>...]\n'> 
                <'\treset bisect state and start bisection.\n'> <'git bisect (bad|new) [<rev>]\n'> <'\tmark <rev> a known-bad revision/\n'> 
                <'\t\ta revision after change in a given property.\n'> <'git bisect (good|old) [<rev>...]\n'> <'\tmark <rev>... known-good revisions/\n'> 
                <'\t\trevisions before change in a given property.\n'> <'git bisect terms [--term-good | --term-bad]\n'> 
                <'\tshow the terms used for old and new commits (default: bad, good)\n'> <'git bisect skip [(<rev>|<range>)...]\n'> <'\tmark <rev>... untestable revisions.\n'> 
                <'git bisect next\n'> <'\tfind next bisection to test and check it out.\n'> <'git bisect reset [<commit>]\n'> 
                <'\tfinish bisection search and go back to commit.\n'> <'git bisect visualize\n'> <'\tshow bisect status in gitk.\n'> <'git bisect replay <logfile>\n'> 
                <'\treplay bisection log.\n'> <'git bisect log\n'> <'\tshow bisect log.\n'> <'git bisect run <cmd>...\n'> 
                <'\tuse <cmd>... to automatically bisect.\n'> <'\n'> <'Please use "git help bisect" to get the full man page.'>
              )
            }
          spids: [9]
        )
      ]
      spids: [9]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:OPTIONS_SPEC spids:[43])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [43]
        )
      ]
      spids: [43]
    )
    (C {(.)} {(git-sh-setup)})
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:_x40 spids:[50])
          op: Equal
          rhs: {(SQ <'[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'>)}
          spids: [50]
        )
      ]
      spids: [50]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:_x40 spids:[55])
          op: Equal
          rhs: 
            {
              (DQ ($ VSub_DollarName '$_x40') ($ VSub_DollarName '$_x40') ($ VSub_DollarName '$_x40') 
                ($ VSub_DollarName '$_x40') ($ VSub_DollarName '$_x40') ($ VSub_DollarName '$_x40') ($ VSub_DollarName '$_x40') 
                ($ VSub_DollarName '$_x40')
              )
            }
          spids: [55]
        )
      ]
      spids: [55]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:TERM_BAD spids:[67])
          op: Equal
          rhs: {(bad)}
          spids: [67]
        )
      ]
      spids: [67]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:TERM_GOOD spids:[70])
          op: Equal
          rhs: {(good)}
          spids: [70]
        )
      ]
      spids: [70]
    )
    (command.FuncDef
      name: bisect_head
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_HEAD))})]
                  action: [(C {(echo)} {(BISECT_HEAD)})]
                  spids: [16777215 93]
                )
              ]
              else_action: [(C {(echo)} {(HEAD)})]
              spids: [101 109]
            )
          ]
          spids: [78]
        )
      spids: [74 77]
    )
    (command.FuncDef
      name: bisect_autostart
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(-s)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_START))})
                (command.BraceGroup
                  children: [
                    (command.SimpleCommand
                      words: [
                        {(gettextln)}
                        {
                          (DQ ('You need to start by ') 
                            (word_part.EscapedLiteralPart
                              token: <Lit_EscapedChar '\\"'>
                            ) ('git bisect start') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>)
                          )
                        }
                      ]
                      redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-t)} {(0)})]
                          action: [
                            (command.SimpleCommand
                              words: [{(gettext)} {(DQ ('Do you want me to do it for you [Y/n]? '))}]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_GreatAnd '>&'>
                                  fd: 16777215
                                  arg_word: {(2)}
                                )
                              ]
                            )
                            (C {(read)} {(yesno)})
                            (command.Case
                              to_match: {(DQ ($ VSub_DollarName '$yesno'))}
                              arms: [
                                (case_arm
                                  pat_list: [{(Lit_Other '[') (Nn) (Lit_Other ']') (Lit_Other '*')}]
                                  action: [(command.ControlFlow token:<ControlFlow_Exit exit>)]
                                  spids: [196 200 205 16777215]
                                )
                              ]
                              spids: [187 193 208]
                            )
                            (C {(bisect_start)})
                          ]
                          spids: [16777215 157]
                        )
                      ]
                      else_action: [(command.ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})]
                      spids: [214 222]
                    )
                  ]
                  spids: [132]
                )
              ]
            )
          ]
          spids: [118]
        )
      spids: [114 117]
    )
    (command.FuncDef
      name: bisect_start
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:has_double_dash spids:[249])
                  op: Equal
                  rhs: {(0)}
                  spids: [249]
                )
              ]
              spids: [249]
            )
            (command.ForEach
              iter_name: arg
              do_arg_iter: T
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ VSub_DollarName '$arg'))}
                      arms: [
                        (case_arm
                          pat_list: [{(--)}]
                          action: [
                            (command.Sentence
                              child: 
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:has_double_dash spids:[272])
                                      op: Equal
                                      rhs: {(1)}
                                      spids: [272]
                                    )
                                  ]
                                  spids: [272]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Break break>
                            )
                          ]
                          spids: [269 270 278 16777215]
                        )
                      ]
                      spids: [261 267 280]
                    )
                  ]
                  spids: [258 283]
                )
              spids: [16777215 16777215]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:orig_args spids:[286])
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(git)} {(rev-parse)} {(--sq-quote)} {(DQ ($ VSub_At '$@'))})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [287 297]
                      )
                    }
                  spids: [286]
                )
              ]
              spids: [286]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:bad_seen spids:[300])
                  op: Equal
                  rhs: {(0)}
                  spids: [300]
                )
              ]
              spids: [300]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:eval spids:[304])
                  op: Equal
                  rhs: {(SQ )}
                  spids: [304]
                )
              ]
              spids: [304]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:must_write_terms spids:[309])
                  op: Equal
                  rhs: {(0)}
                  spids: [309]
                )
              ]
              spids: [309]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:revs spids:[313])
                  op: Equal
                  rhs: {(SQ )}
                  spids: [313]
                )
              ]
              spids: [313]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} 
                      {
                        (DQ (z) 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [(C {(git)} {(rev-parse)} {(--is-bare-repository)})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [324 330]
                          )
                        )
                      } {(KW_Bang '!') (Lit_Other '=')} {(zfalse)}
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:mode spids:[342])
                          op: Equal
                          rhs: {(--no-checkout)}
                          spids: [342]
                        )
                      ]
                      spids: [342]
                    )
                  ]
                  spids: [16777215 339]
                )
              ]
              else_action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:mode spids:[349])
                      op: Equal
                      rhs: {(SQ )}
                      spids: [349]
                    )
                  ]
                  spids: [349]
                )
              ]
              spids: [346 354]
            )
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [
                (command.Sentence
                  child: (C {(Lit_Other '[')} {($ VSub_Pound '$#')} {(-gt)} {(0)} {(Lit_Other ']')})
                  terminator: <Op_Semi ';'>
                )
              ]
              body: 
                (command.DoGroup
                  children: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:arg spids:[373])
                          op: Equal
                          rhs: {(DQ ($ VSub_Number '$1'))}
                          spids: [373]
                        )
                      ]
                      spids: [373]
                    )
                    (command.Case
                      to_match: {(DQ ($ VSub_DollarName '$arg'))}
                      arms: [
                        (case_arm
                          pat_list: [{(--)}]
                          action: [(C {(shift)}) (command.ControlFlow token:<ControlFlow_Break break>)]
                          spids: [388 389 398 16777215]
                        )
                        (case_arm
                          pat_list: [{(--no-checkout)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:mode spids:[405])
                                  op: Equal
                                  rhs: {(--no-checkout)}
                                  spids: [405]
                                )
                              ]
                              spids: [405]
                            )
                            (C {(shift)})
                          ]
                          spids: [401 402 411 16777215]
                        )
                        (case_arm
                          pat_list: [{(--term-good)} {(--term-old)}]
                          action: [
                            (C {(shift)})
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:must_write_terms spids:[423])
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [423]
                                )
                              ]
                              spids: [423]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:TERM_GOOD spids:[427])
                                  op: Equal
                                  rhs: {($ VSub_Number '$1')}
                                  spids: [427]
                                )
                              ]
                              spids: [427]
                            )
                            (C {(shift)})
                          ]
                          spids: [414 417 433 16777215]
                        )
                        (case_arm
                          pat_list: [
                            {(--term-good) (Lit_Other '=') (Lit_Other '*')}
                            {(--term-old) (Lit_Other '=') (Lit_Other '*')}
                          ]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:must_write_terms spids:[446])
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [446]
                                )
                              ]
                              spids: [446]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:TERM_GOOD spids:[450])
                                  op: Equal
                                  rhs: 
                                    {
                                      (word_part.BracedVarSub
                                        token: <VSub_Number 1>
                                        suffix_op: 
                                          (suffix_op.StringUnary
                                            op_id: VOp1_Pound
                                            arg_word: {('*=')}
                                          )
                                        spids: [451 455]
                                      )
                                    }
                                  spids: [450]
                                )
                              ]
                              spids: [450]
                            )
                            (C {(shift)})
                          ]
                          spids: [436 443 460 16777215]
                        )
                        (case_arm
                          pat_list: [{(--term-bad)} {(--term-new)}]
                          action: [
                            (C {(shift)})
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:must_write_terms spids:[472])
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [472]
                                )
                              ]
                              spids: [472]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:TERM_BAD spids:[476])
                                  op: Equal
                                  rhs: {($ VSub_Number '$1')}
                                  spids: [476]
                                )
                              ]
                              spids: [476]
                            )
                            (C {(shift)})
                          ]
                          spids: [463 466 482 16777215]
                        )
                        (case_arm
                          pat_list: [
                            {(--term-bad) (Lit_Other '=') (Lit_Other '*')}
                            {(--term-new) (Lit_Other '=') (Lit_Other '*')}
                          ]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:must_write_terms spids:[495])
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [495]
                                )
                              ]
                              spids: [495]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:TERM_BAD spids:[499])
                                  op: Equal
                                  rhs: 
                                    {
                                      (word_part.BracedVarSub
                                        token: <VSub_Number 1>
                                        suffix_op: 
                                          (suffix_op.StringUnary
                                            op_id: VOp1_Pound
                                            arg_word: {('*=')}
                                          )
                                        spids: [500 504]
                                      )
                                    }
                                  spids: [499]
                                )
                              ]
                              spids: [499]
                            )
                            (C {(shift)})
                          ]
                          spids: [485 492 509 16777215]
                        )
                        (case_arm
                          pat_list: [{(--) (Lit_Other '*')}]
                          action: [
                            (C {(die)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ ("unrecognised option: '") 
                                                (word_part.EscapedLiteralPart
                                                  token: <Lit_EscapedChar '\\$'>
                                                ) ("arg'")
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [520 528]
                                  )
                                )
                              }
                            )
                          ]
                          spids: [512 514 531 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:rev spids:[538])
                                      op: Equal
                                      rhs: 
                                        {
                                          (word_part.CommandSubPart
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (C {(git)} {(rev-parse)} {(-q)} {(--verify)} 
                                                    {(DQ ($ VSub_DollarName '$arg') ('^{commit}'))}
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub '$('>
                                            spids: [539 552]
                                          )
                                        }
                                      spids: [538]
                                    )
                                  ]
                                  spids: [538]
                                )
                                (command.BraceGroup
                                  children: [
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {($ VSub_DollarName '$has_double_dash')} {(-eq)} 
                                          {(1)}
                                        )
                                        (C {(die)} 
                                          {
                                            (DQ 
                                              (word_part.CommandSubPart
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (C {(eval_gettext)} 
                                                        {
                                                          (DQ ("'") 
                                                            (word_part.EscapedLiteralPart
                                                              token: <Lit_EscapedChar '\\$'>
                                                            ) ("arg' does not appear to be a valid revision")
                                                          )
                                                        }
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_CommandSub '$('>
                                                spids: [573 581]
                                              )
                                            )
                                          }
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Break break>
                                    )
                                  ]
                                  spids: [556]
                                )
                              ]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:revs spids:[591])
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ($ VSub_DollarName '$revs') (' ') ($ VSub_DollarName '$rev'))
                                    }
                                  spids: [591]
                                )
                              ]
                              spids: [591]
                            )
                            (C {(shift)})
                          ]
                          spids: [534 535 602 16777215]
                        )
                      ]
                      spids: [379 385 605]
                    )
                  ]
                  spids: [370 608]
                )
            )
            (command.ForEach
              iter_name: rev
              iter_words: [{($ VSub_DollarName '$revs')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:must_write_terms spids:[644])
                          op: Equal
                          rhs: {(1)}
                          spids: [644]
                        )
                      ]
                      spids: [644]
                    )
                    (command.Case
                      to_match: {($ VSub_DollarName '$bad_seen')}
                      arms: [
                        (case_arm
                          pat_list: [{(0)}]
                          action: [
                            (command.Sentence
                              child: 
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:state spids:[659])
                                      op: Equal
                                      rhs: {($ VSub_DollarName '$TERM_BAD')}
                                      spids: [659]
                                    )
                                  ]
                                  spids: [659]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:bad_seen spids:[664])
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [664]
                                )
                              ]
                              spids: [664]
                            )
                          ]
                          spids: [656 657 667 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:state spids:[673])
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$TERM_GOOD')}
                                  spids: [673]
                                )
                              ]
                              spids: [673]
                            )
                          ]
                          spids: [670 671 676 16777215]
                        )
                      ]
                      spids: [649 653 679]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:eval spids:[682])
                          op: Equal
                          rhs: 
                            {
                              (DQ ($ VSub_DollarName '$eval') (" bisect_write '") 
                                ($ VSub_DollarName '$state') ("' '") ($ VSub_DollarName '$rev') ("' 'nolog' &&")
                              )
                            }
                          spids: [682]
                        )
                      ]
                      spids: [682]
                    )
                  ]
                  spids: [621 693]
                )
              spids: [617 16777215]
            )
            (command.AndOr
              ops: [Op_DPipe Op_DPipe]
              children: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:head spids:[708])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (command.SimpleCommand
                                    words: [{(git)} {(symbolic-ref)} {(-q)} {(HEAD)}]
                                    more_env: [
                                      (env_pair
                                        name: GIT_DIR
                                        val: {(DQ ($ VSub_DollarName '$GIT_DIR'))}
                                        spids: [710]
                                      )
                                    ]
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [709 722]
                          )
                        }
                      spids: [708]
                    )
                  ]
                  spids: [708]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:head spids:[727])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (command.SimpleCommand
                                    words: [{(git)} {(rev-parse)} {(--verify)} {(HEAD)}]
                                    more_env: [
                                      (env_pair
                                        name: GIT_DIR
                                        val: {(DQ ($ VSub_DollarName '$GIT_DIR'))}
                                        spids: [729]
                                      )
                                    ]
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [728 741]
                          )
                        }
                      spids: [727]
                    )
                  ]
                  spids: [727]
                )
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(gettext)} {(DQ ('Bad HEAD - I need a HEAD'))})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [749 755]
                      )
                    )
                  }
                )
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:start_head spids:[772])
                  op: Equal
                  rhs: {(SQ )}
                  spids: [772]
                )
              ]
              spids: [772]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-s)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_START))})]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:start_head spids:[796])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(cat)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_START))})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [797 804]
                              )
                            }
                          spids: [796]
                        )
                      ]
                      spids: [796]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(test)} {(DQ (z) ($ VSub_DollarName '$mode'))} 
                              {(KW_Bang '!') (Lit_Other '=')} {(DQ (z--no-checkout))}
                            )
                          ]
                          action: [
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(git)} {(checkout)} {(DQ ($ VSub_DollarName '$start_head'))} {(--)})
                                (C {(die)} 
                                  {
                                    (DQ 
                                      (word_part.CommandSubPart
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(eval_gettext)} 
                                                {
                                                  (DQ ("Checking out '") 
                                                    (word_part.EscapedLiteralPart
                                                      token: <Lit_EscapedChar '\\$'>
                                                    ) ("start_head' failed. Try 'git bisect reset <valid-branch>'.")
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [843 851]
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                          spids: [16777215 824]
                        )
                      ]
                      spids: [16777215 855]
                    )
                  ]
                  spids: [16777215 789]
                )
              ]
              else_action: [
                (command.Case
                  to_match: {(DQ ($ VSub_DollarName '$head'))}
                  arms: [
                    (case_arm
                      pat_list: [{(refs/heads/) (Lit_Other '*')} {($ VSub_DollarName '$_x40')}]
                      action: [
                        (command.AndOr
                          ops: [Op_DAmp]
                          children: [
                            (C {(Lit_Other '[')} {(-s)} 
                              {(DQ ($ VSub_DollarName '$GIT_DIR') (/head-name))} {(Lit_Other ']')}
                            )
                            (C {(die)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(gettext)} {(DQ ("won't bisect on cg-seek'ed tree"))})
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [910 916]
                                  )
                                )
                              }
                            )
                          ]
                        )
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:start_head spids:[920])
                              op: Equal
                              rhs: 
                                {
                                  (DQ 
                                    (word_part.BracedVarSub
                                      token: <VSub_Name head>
                                      suffix_op: 
                                        (suffix_op.StringUnary
                                          op_id: VOp1_Pound
                                          arg_word: {(refs) (Lit_Slash /) (heads) (Lit_Slash /)}
                                        )
                                      spids: [922 929]
                                    )
                                  )
                                }
                              spids: [920]
                            )
                          ]
                          spids: [920]
                        )
                      ]
                      spids: [874 878 933 16777215]
                    )
                    (case_arm
                      pat_list: [{(Lit_Other '*')}]
                      action: [
                        (C {(die)} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(gettext)} {(DQ ('Bad HEAD - strange symbolic ref'))})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [943 949]
                              )
                            )
                          }
                        )
                      ]
                      spids: [936 937 953 16777215]
                    )
                  ]
                  spids: [865 871 956]
                )
              ]
              spids: [858 959]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [(C {(bisect_clean_state)}) (command.ControlFlow token:<ControlFlow_Exit exit>)]
            )
            (C {(trap)} {(SQ <bisect_clean_state>)} {(0)})
            (C {(trap)} {(SQ <'exit 255'>)} {(1)} {(2)} {(3)} {(15)})
            (command.AndOr
              ops: [Op_DAmp Op_DAmp Op_DAmp Op_DAmp Op_DAmp Op_DPipe]
              children: [
                (command.SimpleCommand
                  words: [{(echo)} {(DQ ($ VSub_DollarName '$start_head'))}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_START))}
                    )
                  ]
                )
                (command.BraceGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {(DQ (z) ($ VSub_DollarName '$mode'))} 
                          {(KW_Bang '!') (Lit_Other '=')} {(DQ (z--no-checkout))}
                        )
                        (C {(git)} {(update-ref)} {(--no-deref)} {(BISECT_HEAD)} 
                          {(DQ ($ VSub_DollarName '$start_head'))}
                        )
                      ]
                    )
                  ]
                  spids: [1062]
                )
                (command.SimpleCommand
                  words: [{(git)} {(rev-parse)} {(--sq-quote)} {(DQ ($ VSub_At '$@'))}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_NAMES))}
                    )
                  ]
                )
                (C {(eval)} {(DQ ($ VSub_DollarName '$eval') (' true'))})
                (command.If
                  arms: [
                    (if_arm
                      cond: [(C {(test)} {($ VSub_DollarName '$must_write_terms')} {(-eq)} {(1)})]
                      action: [
                        (C {(write_terms)} {(DQ ($ VSub_DollarName '$TERM_BAD'))} 
                          {(DQ ($ VSub_DollarName '$TERM_GOOD'))}
                        )
                      ]
                      spids: [16777215 1140]
                    )
                  ]
                  spids: [16777215 1154]
                )
                (command.SimpleCommand
                  words: [{(echo)} {(DQ ('git bisect start') ($ VSub_DollarName '$orig_args'))}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_DGreat '>>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_LOG))}
                    )
                  ]
                )
                (command.ControlFlow token:<ControlFlow_Exit exit>)
              ]
            )
            (C {(bisect_auto_next)})
            (C {(trap)} {(SQ <->)} {(0)})
          ]
          spids: [234]
        )
      spids: [230 233]
    )
    (command.FuncDef
      name: bisect_write
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:state spids:[1211])
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$1'))}
                  spids: [1211]
                )
              ]
              spids: [1211]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:rev spids:[1217])
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$2'))}
                  spids: [1217]
                )
              ]
              spids: [1217]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:nolog spids:[1223])
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$3'))}
                  spids: [1223]
                )
              ]
              spids: [1223]
            )
            (command.Case
              to_match: {(DQ ($ VSub_DollarName '$state'))}
              arms: [
                (case_arm
                  pat_list: [{(DQ ($ VSub_DollarName '$TERM_BAD'))}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:tag spids:[1244])
                          op: Equal
                          rhs: {(DQ ($ VSub_DollarName '$state'))}
                          spids: [1244]
                        )
                      ]
                      spids: [1244]
                    )
                  ]
                  spids: [1238 1241 1249 16777215]
                )
                (case_arm
                  pat_list: [{(DQ ($ VSub_DollarName '$TERM_GOOD'))} {(skip)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:tag spids:[1260])
                          op: Equal
                          rhs: {(DQ ($ VSub_DollarName '$state')) (-) (DQ ($ VSub_DollarName '$rev'))}
                          spids: [1260]
                        )
                      ]
                      spids: [1260]
                    )
                  ]
                  spids: [1252 1257 1269 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ('Bad bisect_write argument: ') 
                                        (word_part.EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        ) (state)
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1279 1287]
                          )
                        )
                      }
                    )
                  ]
                  spids: [1272 1273 1290 16777215]
                )
              ]
              spids: [1229 1235 1293]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(git)} {(update-ref)} {(DQ (refs/bisect/) ($ VSub_DollarName '$tag'))} 
                  {(DQ ($ VSub_DollarName '$rev'))}
                )
                (command.ControlFlow token:<ControlFlow_Exit exit>)
              ]
            )
            (command.SimpleCommand
              words: [
                {(echo)}
                {
                  (DQ ('# ') ($ VSub_DollarName '$state') (': ') 
                    (word_part.CommandSubPart
                      command_list: 
                        (command.CommandList
                          children: [(C {(git)} {(show-branch)} {($ VSub_DollarName '$rev')})]
                        )
                      left_token: <Left_CommandSub '$('>
                      spids: [1320 1326]
                    )
                  )
                }
              ]
              redirects: [
                (redir.Redir
                  op: <Redir_DGreat '>>'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_LOG))}
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$nolog'))})
                (command.SimpleCommand
                  words: [
                    {(echo)}
                    {
                      (DQ ('git bisect ') ($ VSub_DollarName '$state') (' ') ($ VSub_DollarName '$rev'))
                    }
                  ]
                  redirects: [
                    (redir.Redir
                      op: <Redir_DGreat '>>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_LOG))}
                    )
                  ]
                )
              ]
            )
          ]
          spids: [1208]
        )
      spids: [1204 1207]
    )
    (command.FuncDef
      name: is_expected_rev
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_EXPECTED_REV))})
                (C {(test)} {(DQ ($ VSub_Number '$1'))} {(Lit_Other '=')} 
                  {
                    (word_part.CommandSubPart
                      command_list: 
                        (command.CommandList
                          children: [
                            (C {(cat)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_EXPECTED_REV))})
                          ]
                        )
                      left_token: <Left_CommandSub '$('>
                      spids: [1391 1398]
                    )
                  }
                )
              ]
            )
          ]
          spids: [1368]
        )
      spids: [1364 1367]
    )
    (command.FuncDef
      name: check_expected_revs
      body: 
        (command.BraceGroup
          children: [
            (command.ForEach
              iter_name: _rev
              iter_words: [{(DQ ($ VSub_At '$@'))}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Pipeline
                              children: [(C {(is_expected_rev)} {(DQ ($ VSub_DollarName '$_rev'))})]
                              negated: T
                            )
                          ]
                          action: [
                            (C {(rm)} {(-f)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_ANCESTORS_OK))})
                            (C {(rm)} {(-f)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_EXPECTED_REV))})
                            (command.ControlFlow
                              token: <ControlFlow_Return return>
                            )
                          ]
                          spids: [16777215 1435]
                        )
                      ]
                      spids: [16777215 1461]
                    )
                  ]
                  spids: [1421 1464]
                )
              spids: [1415 1419]
            )
          ]
          spids: [1407]
        )
      spids: [1403 1406]
    )
    (command.FuncDef
      name: bisect_skip
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:all spids:[1476])
                  op: Equal
                  rhs: {(SQ )}
                  spids: [1476]
                )
              ]
              spids: [1476]
            )
            (command.ForEach
              iter_name: arg
              iter_words: [{(DQ ($ VSub_At '$@'))}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ VSub_DollarName '$arg'))}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Other '*') (..) (Lit_Other '*')}]
                          action: [
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:revs spids:[1510])
                                      op: Equal
                                      rhs: 
                                        {
                                          (word_part.CommandSubPart
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (C {(git)} {(rev-list)} 
                                                    {(DQ ($ VSub_DollarName '$arg'))}
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub '$('>
                                            spids: [1511 1519]
                                          )
                                        }
                                      spids: [1510]
                                    )
                                  ]
                                  spids: [1510]
                                )
                                (C {(die)} 
                                  {
                                    (DQ 
                                      (word_part.CommandSubPart
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(eval_gettext)} 
                                                {
                                                  (DQ ('Bad rev input: ') 
                                                    (word_part.EscapedLiteralPart
                                                      token: <Lit_EscapedChar '\\$'>
                                                    ) (arg)
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [1526 1534]
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                          spids: [1504 1507 1537 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:revs spids:[1544])
                                  op: Equal
                                  rhs: 
                                    {
                                      (word_part.CommandSubPart
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(git)} {(rev-parse)} {(--sq-quote)} 
                                                {(DQ ($ VSub_DollarName '$arg'))}
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [1545 1555]
                                      )
                                    }
                                  spids: [1544]
                                )
                              ]
                              spids: [1544]
                            )
                          ]
                          spids: [1540 1541 1557 16777215]
                        )
                      ]
                      spids: [1495 1501 1560]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:all spids:[1563])
                          op: Equal
                          rhs: {(DQ ($ VSub_DollarName '$all') (' ') ($ VSub_DollarName '$revs'))}
                          spids: [1563]
                        )
                      ]
                      spids: [1563]
                    )
                  ]
                  spids: [1492 1571]
                )
              spids: [1486 16777215]
            )
            (C {(eval)} {(bisect_state)} {(SQ <skip>)} {($ VSub_DollarName '$all')})
          ]
          spids: [1473]
        )
      spids: [1469 1472]
    )
    (command.FuncDef
      name: bisect_state
      body: 
        (command.BraceGroup
          children: [
            (C {(bisect_autostart)})
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:state spids:[1597])
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                  spids: [1597]
                )
              ]
              spids: [1597]
            )
            (C {(check_and_set_terms)} {($ VSub_DollarName '$state')})
            (command.Case
              to_match: {(DQ ($ VSub_Pound '$#') (',') ($ VSub_DollarName '$state'))}
              arms: [
                (case_arm
                  pat_list: [{(0) (Lit_Comma ',') (Lit_Other '*')}]
                  action: [(C {(die)} {(DQ ("Please call 'bisect_state' with at least one argument."))})]
                  spids: [1617 1620 1629 16777215]
                )
                (case_arm
                  pat_list: [
                    {(1) (Lit_Comma ',') (DQ ($ VSub_DollarName '$TERM_BAD'))}
                    {(1) (Lit_Comma ',') (DQ ($ VSub_DollarName '$TERM_GOOD'))}
                    {(1) (Lit_Comma ',') (skip)}
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:bisected_head spids:[1650])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: (command.CommandList children:[(C {(bisect_head)})])
                                left_token: <Left_CommandSub '$('>
                                spids: [1651 1653]
                              )
                            }
                          spids: [1650]
                        )
                      ]
                      spids: [1650]
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:rev spids:[1656])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(git)} {(rev-parse)} {(--verify)} 
                                            {(DQ ($ VSub_DollarName '$bisected_head'))}
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [1657 1667]
                                  )
                                }
                              spids: [1656]
                            )
                          ]
                          spids: [1656]
                        )
                        (C {(die)} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(eval_gettext)} 
                                        {
                                          (DQ ('Bad rev input: ') 
                                            (word_part.EscapedLiteralPart
                                              token: <Lit_EscapedChar '\\$'>
                                            ) (bisected_head)
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [1675 1683]
                              )
                            )
                          }
                        )
                      ]
                    )
                    (C {(bisect_write)} {(DQ ($ VSub_DollarName '$state'))} 
                      {(DQ ($ VSub_DollarName '$rev'))}
                    )
                    (C {(check_expected_revs)} {(DQ ($ VSub_DollarName '$rev'))})
                  ]
                  spids: [1632 1647 1704 16777215]
                )
                (case_arm
                  pat_list: [
                    {(2) (Lit_Comma ',') (DQ ($ VSub_DollarName '$TERM_BAD'))}
                    {(Lit_Other '*') (Lit_Comma ',') (DQ ($ VSub_DollarName '$TERM_GOOD'))}
                    {(Lit_Other '*') (Lit_Comma ',') (skip)}
                  ]
                  action: [
                    (C {(shift)})
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:hash_list spids:[1728])
                          op: Equal
                          rhs: {(SQ )}
                          spids: [1728]
                        )
                      ]
                      spids: [1728]
                    )
                    (command.ForEach
                      iter_name: rev
                      iter_words: [{(DQ ($ VSub_At '$@'))}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:sha spids:[1747])
                                      op: Equal
                                      rhs: 
                                        {
                                          (word_part.CommandSubPart
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (C {(git)} {(rev-parse)} {(--verify)} 
                                                    {(DQ ($ VSub_DollarName '$rev') ('^{commit}'))}
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub '$('>
                                            spids: [1748 1759]
                                          )
                                        }
                                      spids: [1747]
                                    )
                                  ]
                                  spids: [1747]
                                )
                                (C {(die)} 
                                  {
                                    (DQ 
                                      (word_part.CommandSubPart
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(eval_gettext)} 
                                                {
                                                  (DQ ('Bad rev input: ') 
                                                    (word_part.EscapedLiteralPart
                                                      token: <Lit_EscapedChar '\\$'>
                                                    ) (rev)
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [1767 1775]
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:hash_list spids:[1779])
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ($ VSub_DollarName '$hash_list') (' ') 
                                        ($ VSub_DollarName '$sha')
                                      )
                                    }
                                  spids: [1779]
                                )
                              ]
                              spids: [1779]
                            )
                          ]
                          spids: [1744 1787]
                        )
                      spids: [1738 16777215]
                    )
                    (command.ForEach
                      iter_name: rev
                      iter_words: [{($ VSub_DollarName '$hash_list')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (C {(bisect_write)} {(DQ ($ VSub_DollarName '$state'))} 
                              {(DQ ($ VSub_DollarName '$rev'))}
                            )
                          ]
                          spids: [1799 1813]
                        )
                      spids: [1795 16777215]
                    )
                    (C {(check_expected_revs)} {($ VSub_DollarName '$hash_list')})
                  ]
                  spids: [1707 1722 1820 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*') (Lit_Comma ',') (DQ ($ VSub_DollarName '$TERM_BAD'))}]
                  action: [
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ("'git bisect ") 
                                        (word_part.EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        ) ("TERM_BAD' can take only one argument.")
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1834 1842]
                          )
                        )
                      }
                    )
                  ]
                  spids: [1823 1828 1845 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [(C {(usage)})]
                  spids: [1848 1849 1854 16777215]
                )
              ]
              spids: [1606 1614 1857]
            )
            (C {(bisect_auto_next)})
          ]
          spids: [1591]
        )
      spids: [1587 1590]
    )
    (command.FuncDef
      name: bisect_next_check
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:missing_good spids:[1872])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [1872]
                )
                (assign_pair
                  lhs: (lhs_expr.LhsName name:missing_bad spids:[1874])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [1874]
                )
              ]
              spids: [1872]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(git)} {(show-ref)} {(-q)} {(--verify)} 
                  {(refs/bisect/) ($ VSub_DollarName '$TERM_BAD')}
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:missing_bad spids:[1890])
                      op: Equal
                      rhs: {(t)}
                      spids: [1890]
                    )
                  ]
                  spids: [1890]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(-n)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(git)} {(for-each-ref)} 
                                {(DQ (refs/bisect/) ($ VSub_DollarName '$TERM_GOOD') ('-*'))}
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1899 1909]
                      )
                    )
                  }
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:missing_good spids:[1914])
                      op: Equal
                      rhs: {(t)}
                      spids: [1914]
                    )
                  ]
                  spids: [1914]
                )
              ]
            )
            (command.Case
              to_match: 
                {
                  (DQ ($ VSub_DollarName '$missing_good') (',') ($ VSub_DollarName '$missing_bad') (',') 
                    ($ VSub_Number '$1')
                  )
                }
              arms: [
                (case_arm
                  pat_list: [{(Lit_Comma ',') (Lit_Comma ',') (Lit_Other '*')}]
                  action: [
                    (C {(Lit_Other ':')} {(have)} {(both)} {($ VSub_DollarName '$TERM_GOOD')} {(and)} 
                      {($ VSub_DollarName '$TERM_BAD')} {(-)} {(ok)}
                    )
                  ]
                  spids: [1932 1935 1955 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*') (Lit_Comma ',')}]
                  action: [(C {(false)})]
                  spids: [1958 1960 1970 16777215]
                )
                (case_arm
                  pat_list: [
                    {(t) (Lit_Comma ',') (Lit_Comma ',') (DQ ($ VSub_DollarName '$TERM_GOOD'))}
                  ]
                  action: [
                    (command.SimpleCommand
                      words: [
                        {(eval_gettextln)}
                        {
                          (DQ ('Warning: bisecting only with a ') 
                            (word_part.EscapedLiteralPart
                              token: <Lit_EscapedChar '\\$'>
                            ) ('TERM_BAD commit.')
                          )
                        }
                      ]
                      redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-t)} {(0)})]
                          action: [
                            (command.SimpleCommand
                              words: [{(gettext)} {(DQ ('Are you sure [Y/n]? '))}]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_GreatAnd '>&'>
                                  fd: 16777215
                                  arg_word: {(2)}
                                )
                              ]
                            )
                            (C {(read)} {(yesno)})
                            (command.Case
                              to_match: {(DQ ($ VSub_DollarName '$yesno'))}
                              arms: [
                                (case_arm
                                  pat_list: [{(Lit_Other '[') (Nn) (Lit_Other ']') (Lit_Other '*')}]
                                  action: [
                                    (command.ControlFlow
                                      token: <ControlFlow_Exit exit>
                                      arg_word: {(1)}
                                    )
                                  ]
                                  spids: [2049 2053 2059 16777215]
                                )
                              ]
                              spids: [2041 2047 2061]
                            )
                          ]
                          spids: [16777215 2011]
                        )
                      ]
                      spids: [16777215 2064]
                    )
                    (C {(Lit_Other ':')} {(bisect)} {(without)} {($ VSub_DollarName '$TERM_GOOD') (...)})
                  ]
                  spids: [1973 1979 2077 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:bad_syn spids:[2084])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(bisect_voc)} {(bad)})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [2085 2089]
                              )
                            }
                          spids: [2084]
                        )
                      ]
                      spids: [2084]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:good_syn spids:[2092])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(bisect_voc)} {(good)})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [2093 2097]
                              )
                            }
                          spids: [2092]
                        )
                      ]
                      spids: [2092]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(test)} {(-s)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_START))})
                          ]
                          action: [
                            (command.SimpleCommand
                              words: [
                                {(eval_gettextln)}
                                {
                                  (DQ ('You need to give me at least one ') 
                                    (word_part.EscapedLiteralPart
                                      token: <Lit_EscapedChar '\\$'>
                                    ) ('bad_syn and one ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) 
                                    ('good_syn revision.\n') ('(You can use ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) ('git bisect ') 
                                    (word_part.EscapedLiteralPart
                                      token: <Lit_EscapedChar '\\$'>
                                    ) (bad_syn) (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) (' and ') 
                                    (word_part.EscapedLiteralPart
                                      token: <Lit_EscapedChar '\\"'>
                                    ) ('git bisect ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) (good_syn) 
                                    (word_part.EscapedLiteralPart
                                      token: <Lit_EscapedChar '\\"'>
                                    ) (' for that.)')
                                  )
                                }
                              ]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_GreatAnd '>&'>
                                  fd: 16777215
                                  arg_word: {(2)}
                                )
                              ]
                            )
                          ]
                          spids: [16777215 2112]
                        )
                      ]
                      else_action: [
                        (command.SimpleCommand
                          words: [
                            {(eval_gettextln)}
                            {
                              (DQ ('You need to start by ') 
                                (word_part.EscapedLiteralPart
                                  token: <Lit_EscapedChar '\\"'>
                                ) ('git bisect start') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) ('.\n') 
                                ('You then need to give me at least one ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) ('good_syn and one ') 
                                (word_part.EscapedLiteralPart
                                  token: <Lit_EscapedChar '\\$'>
                                ) ('bad_syn revision.\n') ('(You can use ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) 
                                ('git bisect ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) (bad_syn) 
                                (word_part.EscapedLiteralPart
                                  token: <Lit_EscapedChar '\\"'>
                                ) (' and ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) ('git bisect ') 
                                (word_part.EscapedLiteralPart
                                  token: <Lit_EscapedChar '\\$'>
                                ) (good_syn) (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) (' for that.)')
                              )
                            }
                          ]
                          redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
                        )
                      ]
                      spids: [2143 2178]
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {(1)}
                    )
                  ]
                  spids: [2080 2081 2185 16777215]
                )
              ]
              spids: [1919 1929 2188]
            )
          ]
          spids: [1869]
        )
      spids: [1865 1868]
    )
    (command.FuncDef
      name: bisect_auto_next
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp Op_DPipe]
              children: [(C {(bisect_next_check)}) (C {(bisect_next)}) (C {(Lit_Other ':')})]
            )
          ]
          spids: [2197]
        )
      spids: [2193 2196]
    )
    (command.FuncDef
      name: bisect_next
      body: 
        (command.BraceGroup
          children: [
            (command.Case
              to_match: {(DQ ($ VSub_Pound '$#'))}
              arms: [
                (case_arm pat_list:[{(0)}] spids:[2228 2229 2231 16777215])
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [(C {(usage)})]
                  spids: [2233 2234 2238 16777215]
                )
              ]
              spids: [2220 2226 2240]
            )
            (C {(bisect_autostart)})
            (C {(bisect_next_check)} {($ VSub_DollarName '$TERM_GOOD')})
            (C {(git)} {(bisect--helper)} {(--next-all)} 
              {
                (word_part.CommandSubPart
                  command_list: 
                    (command.CommandList
                      children: [
                        (command.AndOr
                          ops: [Op_DAmp]
                          children: [
                            (C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_HEAD))})
                            (C {(echo)} {(--no-checkout)})
                          ]
                        )
                      ]
                    )
                  left_token: <Left_CommandSub '$('>
                  spids: [2262 2277]
                )
              }
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:res spids:[2280])
                  op: Equal
                  rhs: {($ VSub_QMark '$?')}
                  spids: [2280]
                )
              ]
              spids: [2280]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {($ VSub_DollarName '$res')} {(-eq)} {(10)})]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:bad_rev spids:[2303])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(git)} {(show-ref)} {(--hash)} {(--verify)} 
                                        {(refs/bisect/) ($ VSub_DollarName '$TERM_BAD')}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [2304 2315]
                              )
                            }
                          spids: [2303]
                        )
                      ]
                      spids: [2303]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:bad_commit spids:[2318])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(git)} {(show-branch)} {($ VSub_DollarName '$bad_rev')})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [2319 2325]
                              )
                            }
                          spids: [2318]
                        )
                      ]
                      spids: [2318]
                    )
                    (command.SimpleCommand
                      words: [
                        {(echo)}
                        {
                          (DQ ('# first ') ($ VSub_DollarName '$TERM_BAD') (' commit: ') 
                            ($ VSub_DollarName '$bad_commit')
                          )
                        }
                      ]
                      redirects: [
                        (redir.Redir
                          op: <Redir_DGreat '>>'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_LOG))}
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {(0)}
                    )
                  ]
                  spids: [16777215 2300]
                )
                (if_arm
                  cond: [(C {(test)} {($ VSub_DollarName '$res')} {(-eq)} {(2)})]
                  action: [
                    (command.SimpleCommand
                      words: [{(echo)} {(DQ ('# only skipped commits left to test'))}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_DGreat '>>'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_LOG))}
                        )
                      ]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:good_revs spids:[2376])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(git)} {(for-each-ref)} 
                                        {(--format) (Lit_Other '=') (DQ ('%(objectname)'))} {(DQ (refs/bisect/) ($ VSub_DollarName '$TERM_GOOD') ('-*'))}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [2377 2393]
                              )
                            }
                          spids: [2376]
                        )
                      ]
                      spids: [2376]
                    )
                    (command.ForEach
                      iter_name: skipped
                      iter_words: [
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(git)} {(rev-list)} 
                                    {(refs/bisect/) ($ VSub_DollarName '$TERM_BAD')} {(--not)} {($ VSub_DollarName '$good_revs')}
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2402 2413]
                          )
                        }
                      ]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:skipped_commit spids:[2419])
                                  op: Equal
                                  rhs: 
                                    {
                                      (word_part.CommandSubPart
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(git)} {(show-branch)} 
                                                {($ VSub_DollarName '$skipped')}
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [2420 2426]
                                      )
                                    }
                                  spids: [2419]
                                )
                              ]
                              spids: [2419]
                            )
                            (command.SimpleCommand
                              words: [
                                {(echo)}
                                {
                                  (DQ ('# possible first ') ($ VSub_DollarName '$TERM_BAD') 
                                    (' commit: ') ($ VSub_DollarName '$skipped_commit')
                                  )
                                }
                              ]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_DGreat '>>'>
                                  fd: 16777215
                                  arg_word: {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_LOG))}
                                )
                              ]
                            )
                          ]
                          spids: [2416 2445]
                        )
                      spids: [2401 16777215]
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {($ VSub_DollarName '$res')}
                    )
                  ]
                  spids: [2349 2360]
                )
              ]
              spids: [16777215 2453]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {($ VSub_DollarName '$res')} {(-ne)} {(0)})
                (command.ControlFlow
                  token: <ControlFlow_Exit exit>
                  arg_word: {($ VSub_DollarName '$res')}
                )
              ]
            )
            (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
          ]
          spids: [2217]
        )
      spids: [2213 2216]
    )
    (command.FuncDef
      name: bisect_visualize
      body: 
        (command.BraceGroup
          children: [
            (C {(bisect_next_check)} {(fail)})
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {($ VSub_Pound '$#')} {(Lit_Other '=')} {(0)})]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {(-n)} 
                                  {
                                    (DQ 
                                      (word_part.BracedVarSub
                                        token: <VSub_Name DISPLAY>
                                        suffix_op: 
                                          (suffix_op.StringUnary
                                            op_id: VTest_Plus
                                            arg_word: {(set)}
                                          )
                                        spids: [2518 2522]
                                      ) 
                                      (word_part.BracedVarSub
                                        token: <VSub_Name SESSIONNAME>
                                        suffix_op: 
                                          (suffix_op.StringUnary
                                            op_id: VTest_Plus
                                            arg_word: {(set)}
                                          )
                                        spids: [2523 2527]
                                      ) 
                                      (word_part.BracedVarSub
                                        token: <VSub_Name MSYSTEM>
                                        suffix_op: 
                                          (suffix_op.StringUnary
                                            op_id: VTest_Plus
                                            arg_word: {(set)}
                                          )
                                        spids: [2528 2532]
                                      ) 
                                      (word_part.BracedVarSub
                                        token: <VSub_Name SECURITYSESSIONID>
                                        suffix_op: 
                                          (suffix_op.StringUnary
                                            op_id: VTest_Plus
                                            arg_word: {(set)}
                                          )
                                        spids: [2533 2537]
                                      )
                                    )
                                  }
                                )
                                (command.SimpleCommand
                                  words: [{(type)} {(gitk)}]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_Great '>'>
                                      fd: 16777215
                                      arg_word: {(/dev/null)}
                                    )
                                    (redir.Redir
                                      op: <Redir_GreatAnd '2>&'>
                                      fd: 2
                                      arg_word: {(1)}
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                          action: [(C {(set)} {(gitk)})]
                          spids: [16777215 2554]
                        )
                      ]
                      else_action: [(C {(set)} {(git)} {(log)})]
                      spids: [2562 2572]
                    )
                  ]
                  spids: [16777215 2508]
                )
              ]
              else_action: [
                (command.Case
                  to_match: {(DQ ($ VSub_Number '$1'))}
                  arms: [
                    (case_arm
                      pat_list: [{(git) (Lit_Other '*')} {(tig)}]
                      spids: [2587 2591 2593 16777215]
                    )
                    (case_arm
                      pat_list: [{(-) (Lit_Other '*')}]
                      action: [(C {(set)} {(git)} {(log)} {(DQ ($ VSub_At '$@'))})]
                      spids: [2596 2598 2610 16777215]
                    )
                    (case_arm
                      pat_list: [{(Lit_Other '*')}]
                      action: [(C {(set)} {(git)} {(DQ ($ VSub_At '$@'))})]
                      spids: [2613 2614 2624 16777215]
                    )
                  ]
                  spids: [2578 2584 2627]
                )
              ]
              spids: [2575 2630]
            )
            (C {(eval)} {(SQ <'"$@"'>)} {(--bisect)} {(--)} 
              {
                (word_part.CommandSubPart
                  command_list: 
                    (command.CommandList
                      children: [(C {(cat)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_NAMES))})]
                    )
                  left_token: <Left_CommandSub '$('>
                  spids: [2644 2651]
                )
              }
            )
          ]
          spids: [2488]
        )
      spids: [2484 2487]
    )
    (command.FuncDef
      name: bisect_reset
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(-s)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_START))})
                (command.BraceGroup
                  children: [
                    (C {(gettextln)} {(DQ ('We are not bisecting.'))})
                    (command.ControlFlow token:<ControlFlow_Return return>)
                  ]
                  spids: [2674]
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ VSub_Pound '$#'))}
              arms: [
                (case_arm
                  pat_list: [{(0)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:branch spids:[2702])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(cat)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_START))})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [2703 2710]
                              )
                            }
                          spids: [2702]
                        )
                      ]
                      spids: [2702]
                    )
                  ]
                  spids: [2699 2700 2712 16777215]
                )
                (case_arm
                  pat_list: [{(1)}]
                  action: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (command.SimpleCommand
                          words: [
                            {(git)}
                            {(rev-parse)}
                            {(--quiet)}
                            {(--verify)}
                            {(DQ ($ VSub_Number '$1') ('^{commit}'))}
                          ]
                          redirects: [
                            (redir.Redir
                              op: <Redir_Great '>'>
                              fd: 16777215
                              arg_word: {(/dev/null)}
                            )
                          ]
                        )
                        (command.BraceGroup
                          children: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:invalid spids:[2739])
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number '$1'))}
                                  spids: [2739]
                                )
                              ]
                              spids: [2739]
                            )
                            (C {(die)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ ("'") 
                                                (word_part.EscapedLiteralPart
                                                  token: <Lit_EscapedChar '\\$'>
                                                ) ("invalid' is not a valid commit")
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [2748 2756]
                                  )
                                )
                              }
                            )
                          ]
                          spids: [2736]
                        )
                      ]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:branch spids:[2763])
                          op: Equal
                          rhs: {(DQ ($ VSub_Number '$1'))}
                          spids: [2763]
                        )
                      ]
                      spids: [2763]
                    )
                  ]
                  spids: [2715 2716 2768 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [(C {(usage)})]
                  spids: [2771 2772 2777 16777215]
                )
              ]
              spids: [2690 2696 2780]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (command.Pipeline
                          children: [
                            (C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_HEAD))})
                          ]
                          negated: T
                        )
                        (command.Pipeline
                          children: [
                            (C {(git)} {(checkout)} {(DQ ($ VSub_DollarName '$branch'))} {(--)})
                          ]
                          negated: T
                        )
                      ]
                    )
                  ]
                  action: [
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ("Could not check out original HEAD '") 
                                        (word_part.EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        ) ("branch'.\n") ("Try 'git bisect reset <commit>'.")
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2818 2827]
                          )
                        )
                      }
                    )
                  ]
                  spids: [16777215 2812]
                )
              ]
              spids: [16777215 2831]
            )
            (C {(bisect_clean_state)})
          ]
          spids: [2660]
        )
      spids: [2656 2659]
    )
    (command.FuncDef
      name: bisect_clean_state
      body: 
        (command.BraceGroup
          children: [
            (command.Pipeline
              children: [
                (C {(git)} {(for-each-ref)} 
                  {(--format) (Lit_Other '=') (SQ <'%(refname) %(objectname)'>)} {(refs/bisect/) (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\*'>)}
                )
                (command.WhileUntil
                  keyword: <KW_While while>
                  cond: [(C {(read)} {(ref)} {(hash)})]
                  body: 
                    (command.DoGroup
                      children: [
                        (command.AndOr
                          ops: [Op_DPipe]
                          children: [
                            (C {(git)} {(update-ref)} {(-d)} {($ VSub_DollarName '$ref')} 
                              {($ VSub_DollarName '$hash')}
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Exit exit>
                            )
                          ]
                        )
                      ]
                      spids: [2875 2893]
                    )
                )
              ]
              negated: F
            )
            (command.AndOr
              ops: [Op_DAmp Op_DAmp Op_DAmp Op_DAmp Op_DAmp Op_DAmp Op_DAmp Op_DAmp]
              children: [
                (C {(rm)} {(-f)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_EXPECTED_REV))})
                (C {(rm)} {(-f)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_ANCESTORS_OK))})
                (C {(rm)} {(-f)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_LOG))})
                (C {(rm)} {(-f)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_NAMES))})
                (C {(rm)} {(-f)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_RUN))})
                (C {(rm)} {(-f)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_TERMS))})
                (C {(rm)} {(-f)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/head-name))})
                (C {(git)} {(update-ref)} {(-d)} {(--no-deref)} {(BISECT_HEAD)})
                (C {(rm)} {(-f)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_START))})
              ]
            )
          ]
          spids: [2843]
        )
      spids: [2839 2842]
    )
    (command.FuncDef
      name: bisect_replay
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:file spids:[3021])
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$1'))}
                  spids: [3021]
                )
              ]
              spids: [3021]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(DQ ($ VSub_Pound '$#'))} {(-eq)} {(1)})
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(gettext)} {(DQ ('No logfile given'))})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [3042 3048]
                      )
                    )
                  }
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(-r)} {(DQ ($ VSub_DollarName '$file'))})
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ('cannot read ') 
                                    (word_part.EscapedLiteralPart
                                      token: <Lit_EscapedChar '\\$'>
                                    ) ('file for replaying')
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [3065 3073]
                      )
                    )
                  }
                )
              ]
            )
            (C {(bisect_reset)})
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(C {(read)} {(git)} {(bisect)} {(command)} {(rev)})]
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DPipe Op_DPipe]
                      children: [
                        (C {(test)} 
                          {(DQ ($ VSub_DollarName '$git') (' ') ($ VSub_DollarName '$bisect'))} {(Lit_Other '=')} {(DQ ('git bisect'))}
                        )
                        (C {(test)} {(DQ ($ VSub_DollarName '$git'))} {(Lit_Other '=')} 
                          {(DQ (git-bisect))}
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Continue continue>
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(test)} {(DQ ($ VSub_DollarName '$git'))} {(Lit_Other '=')} 
                              {(DQ (git-bisect))}
                            )
                          ]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:rev spids:[3147])
                                  op: Equal
                                  rhs: {(DQ ($ VSub_DollarName '$command'))}
                                  spids: [3147]
                                )
                              ]
                              spids: [3147]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:command spids:[3153])
                                  op: Equal
                                  rhs: {(DQ ($ VSub_DollarName '$bisect'))}
                                  spids: [3153]
                                )
                              ]
                              spids: [3153]
                            )
                          ]
                          spids: [16777215 3144]
                        )
                      ]
                      spids: [16777215 3159]
                    )
                    (C {(get_terms)})
                    (C {(check_and_set_terms)} {(DQ ($ VSub_DollarName '$command'))})
                    (command.Case
                      to_match: {(DQ ($ VSub_DollarName '$command'))}
                      arms: [
                        (case_arm
                          pat_list: [{(start)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:cmd spids:[3185])
                                  op: Equal
                                  rhs: {(DQ ('bisect_start ') ($ VSub_DollarName '$rev'))}
                                  spids: [3185]
                                )
                              ]
                              spids: [3185]
                            )
                            (C {(eval)} {(DQ ($ VSub_DollarName '$cmd'))})
                          ]
                          spids: [3181 3182 3198 16777215]
                        )
                        (case_arm
                          pat_list: [
                            {(DQ ($ VSub_DollarName '$TERM_GOOD'))}
                            {(DQ ($ VSub_DollarName '$TERM_BAD'))}
                            {(skip)}
                          ]
                          action: [
                            (C {(bisect_write)} {(DQ ($ VSub_DollarName '$command'))} 
                              {(DQ ($ VSub_DollarName '$rev'))}
                            )
                          ]
                          spids: [3201 3210 3223 16777215]
                        )
                        (case_arm
                          pat_list: [{(terms)}]
                          action: [(C {(bisect_terms)} {($ VSub_DollarName '$rev')})]
                          spids: [3226 3227 3234 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [
                            (C {(die)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(gettext)} {(DQ ('?? what are you talking about?'))})
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [3244 3250]
                                  )
                                )
                              }
                            )
                          ]
                          spids: [3237 3238 3253 16777215]
                        )
                      ]
                      spids: [3172 3178 3256]
                    )
                  ]
                  spids: [3093 3259]
                )
              redirects: [
                (redir.Redir
                  op: <Redir_Less '<'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_DollarName '$file'))}
                )
              ]
            )
            (C {(bisect_auto_next)})
          ]
          spids: [3018]
        )
      spids: [3013 3017]
    )
    (command.FuncDef
      name: bisect_run
      body: 
        (command.BraceGroup
          children: [
            (C {(bisect_next_check)} {(fail)})
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(C {(true)})]
              body: 
                (command.DoGroup
                  children: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:command spids:[3294])
                          op: Equal
                          rhs: {(DQ ($ VSub_At '$@'))}
                          spids: [3294]
                        )
                      ]
                      spids: [3294]
                    )
                    (C {(eval_gettextln)} 
                      {
                        (DQ ('running ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) 
                          (command)
                        )
                      }
                    )
                    (C {(DQ ($ VSub_At '$@'))})
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:res spids:[3314])
                          op: Equal
                          rhs: {($ VSub_QMark '$?')}
                          spids: [3314]
                        )
                      ]
                      spids: [3314]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(Lit_Other '[')} {($ VSub_DollarName '$res')} {(-lt)} {(0)} {(-o)} 
                              {($ VSub_DollarName '$res')} {(-ge)} {(128)} {(Lit_Other ']')}
                            )
                          ]
                          action: [
                            (command.SimpleCommand
                              words: [
                                {(eval_gettextln)}
                                {
                                  (DQ ('bisect run failed:\n') ('exit code ') 
                                    (word_part.EscapedLiteralPart
                                      token: <Lit_EscapedChar '\\$'>
                                    ) ("res from '") (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) 
                                    ("command' is < 0 or >= 128")
                                  )
                                }
                              ]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_GreatAnd '>&'>
                                  fd: 16777215
                                  arg_word: {(2)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Exit exit>
                              arg_word: {($ VSub_DollarName '$res')}
                            )
                          ]
                          spids: [16777215 3344]
                        )
                      ]
                      spids: [16777215 3367]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(Lit_Other '[')} {($ VSub_DollarName '$res')} {(-eq)} {(125)} 
                              {(Lit_Other ']')}
                            )
                          ]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:state spids:[3395])
                                  op: Equal
                                  rhs: {(SQ <skip>)}
                                  spids: [3395]
                                )
                              ]
                              spids: [3395]
                            )
                          ]
                          spids: [16777215 3392]
                        )
                        (if_arm
                          cond: [
                            (C {(Lit_Other '[')} {($ VSub_DollarName '$res')} {(-gt)} {(0)} 
                              {(Lit_Other ']')}
                            )
                          ]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:state spids:[3417])
                                  op: Equal
                                  rhs: {(DQ ($ VSub_DollarName '$TERM_BAD'))}
                                  spids: [3417]
                                )
                              ]
                              spids: [3417]
                            )
                          ]
                          spids: [3401 3414]
                        )
                      ]
                      else_action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:state spids:[3426])
                              op: Equal
                              rhs: {(DQ ($ VSub_DollarName '$TERM_GOOD'))}
                              spids: [3426]
                            )
                          ]
                          spids: [3426]
                        )
                      ]
                      spids: [3423 3432]
                    )
                    (command.Subshell
                      child: 
                        (command.SimpleCommand
                          words: [{(bisect_state)} {($ VSub_DollarName '$state')}]
                          redirects: [
                            (redir.Redir
                              op: <Redir_Great '>'>
                              fd: 16777215
                              arg_word: {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_RUN))}
                            )
                          ]
                        )
                      spids: [3440 3452]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:res spids:[3455])
                          op: Equal
                          rhs: {($ VSub_QMark '$?')}
                          spids: [3455]
                        )
                      ]
                      spids: [3455]
                    )
                    (C {(cat)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_RUN))})
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.SimpleCommand
                              words: [
                                {(sane_grep)}
                                {
                                  (DQ ('first ') ($ VSub_DollarName '$TERM_BAD') 
                                    (' commit could be any of')
                                  )
                                }
                                {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_RUN))}
                              ]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_Great '>'>
                                  fd: 16777215
                                  arg_word: {(/dev/null)}
                                )
                              ]
                            )
                          ]
                          action: [
                            (command.SimpleCommand
                              words: [{(gettextln)} {(DQ ('bisect run cannot continue any more'))}]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_GreatAnd '>&'>
                                  fd: 16777215
                                  arg_word: {(2)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Exit exit>
                              arg_word: {($ VSub_DollarName '$res')}
                            )
                          ]
                          spids: [16777215 3490]
                        )
                      ]
                      spids: [16777215 3508]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(Lit_Other '[')} {($ VSub_DollarName '$res')} {(-ne)} {(0)} 
                              {(Lit_Other ']')}
                            )
                          ]
                          action: [
                            (command.SimpleCommand
                              words: [
                                {(eval_gettextln)}
                                {
                                  (DQ ('bisect run failed:\n') ("'bisect_state ") 
                                    (word_part.EscapedLiteralPart
                                      token: <Lit_EscapedChar '\\$'>
                                    ) ("state' exited with error code ") (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) (res)
                                  )
                                }
                              ]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_GreatAnd '>&'>
                                  fd: 16777215
                                  arg_word: {(2)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Exit exit>
                              arg_word: {($ VSub_DollarName '$res')}
                            )
                          ]
                          spids: [16777215 3525]
                        )
                      ]
                      spids: [16777215 3548]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.SimpleCommand
                              words: [
                                {(sane_grep)}
                                {(DQ ('is the first ') ($ VSub_DollarName '$TERM_BAD') (' commit'))}
                                {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_RUN))}
                              ]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_Great '>'>
                                  fd: 16777215
                                  arg_word: {(/dev/null)}
                                )
                              ]
                            )
                          ]
                          action: [
                            (C {(gettextln)} {(DQ ('bisect run success'))})
                            (command.Sentence
                              child: (command.ControlFlow token:<ControlFlow_Exit exit> arg_word:{(0)})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          spids: [16777215 3571]
                        )
                      ]
                      spids: [16777215 3587]
                    )
                  ]
                  spids: [3291 3591]
                )
            )
          ]
          spids: [3277]
        )
      spids: [3272 3276]
    )
    (command.FuncDef
      name: bisect_log
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(-s)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_LOG))})
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(gettext)} {(DQ ('We are not bisecting.'))})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [3618 3624]
                      )
                    )
                  }
                )
              ]
            )
            (C {(cat)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_LOG))})
          ]
          spids: [3601]
        )
      spids: [3596 3600]
    )
    (command.FuncDef
      name: get_terms
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-s)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_TERMS))})]
                  action: [
                    (command.BraceGroup
                      children: [(C {(read)} {(TERM_BAD)}) (C {(read)} {(TERM_GOOD)})]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Less '<'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_TERMS))}
                        )
                      ]
                      spids: [3661]
                    )
                  ]
                  spids: [16777215 3658]
                )
              ]
              spids: [16777215 3683]
            )
          ]
          spids: [3643]
        )
      spids: [3638 3642]
    )
    (command.FuncDef
      name: write_terms
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:TERM_BAD spids:[3696])
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                  spids: [3696]
                )
              ]
              spids: [3696]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:TERM_GOOD spids:[3700])
                  op: Equal
                  rhs: {($ VSub_Number '$2')}
                  spids: [3700]
                )
              ]
              spids: [3700]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} {(DQ ($ VSub_DollarName '$TERM_BAD'))} {(Lit_Other '=')} 
                      {(DQ ($ VSub_DollarName '$TERM_GOOD'))}
                    )
                  ]
                  action: [
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [(C {(gettext)} {(DQ ('please use two different terms'))})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [3725 3731]
                          )
                        )
                      }
                    )
                  ]
                  spids: [16777215 3719]
                )
              ]
              spids: [16777215 3735]
            )
            (C {(check_term_format)} {(DQ ($ VSub_DollarName '$TERM_BAD'))} {(bad)})
            (C {(check_term_format)} {(DQ ($ VSub_DollarName '$TERM_GOOD'))} {(good)})
            (command.SimpleCommand
              words: [
                {(printf)}
                {(SQ <'%s\\n%s\\n'>)}
                {(DQ ($ VSub_DollarName '$TERM_BAD'))}
                {(DQ ($ VSub_DollarName '$TERM_GOOD'))}
              ]
              redirects: [
                (redir.Redir
                  op: <Redir_Great '>'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_TERMS))}
                )
              ]
            )
          ]
          spids: [3693]
        )
      spids: [3688 3692]
    )
    (command.FuncDef
      name: check_term_format
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:term spids:[3787])
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                  spids: [3787]
                )
              ]
              spids: [3787]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(git)} {(check-ref-format)} {(refs/bisect/) (DQ ($ VSub_DollarName '$term'))})
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ("'") 
                                    (word_part.EscapedLiteralPart
                                      token: <Lit_EscapedChar '\\$'>
                                    ) ("term' is not a valid term")
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [3806 3814]
                      )
                    )
                  }
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ VSub_DollarName '$term'))}
              arms: [
                (case_arm
                  pat_list: [
                    {(help)}
                    {(start)}
                    {(terms)}
                    {(skip)}
                    {(next)}
                    {(reset)}
                    {(visualize)}
                    {(replay)}
                    {(log)}
                    {(run)}
                  ]
                  action: [
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ("can't use the builtin command '") 
                                        (word_part.EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        ) ("term' as a term")
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [3852 3860]
                          )
                        )
                      }
                    )
                  ]
                  spids: [3827 3846 3864 16777215]
                )
                (case_arm
                  pat_list: [{(bad)} {(new)}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(test)} {(DQ ($ VSub_Number '$2'))} {(KW_Bang '!') (Lit_Other '=')} 
                              {(bad)}
                            )
                          ]
                          action: [
                            (C {(die)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ ("can't change the meaning of term '") 
                                                (word_part.EscapedLiteralPart
                                                  token: <Lit_EscapedChar '\\$'>
                                                ) ("term'")
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [3909 3917]
                                  )
                                )
                              }
                            )
                          ]
                          spids: [16777215 3887]
                        )
                      ]
                      spids: [16777215 3921]
                    )
                  ]
                  spids: [3867 3870 3924 16777215]
                )
                (case_arm
                  pat_list: [{(good)} {(old)}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(test)} {(DQ ($ VSub_Number '$2'))} {(KW_Bang '!') (Lit_Other '=')} 
                              {(good)}
                            )
                          ]
                          action: [
                            (C {(die)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ ("can't change the meaning of term '") 
                                                (word_part.EscapedLiteralPart
                                                  token: <Lit_EscapedChar '\\$'>
                                                ) ("term'")
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [3953 3961]
                                  )
                                )
                              }
                            )
                          ]
                          spids: [16777215 3947]
                        )
                      ]
                      spids: [16777215 3965]
                    )
                  ]
                  spids: [3927 3930 3968 16777215]
                )
              ]
              spids: [3818 3824 3971]
            )
          ]
          spids: [3784]
        )
      spids: [3779 3783]
    )
    (command.FuncDef
      name: check_and_set_terms
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:cmd spids:[3984])
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$1'))}
                  spids: [3984]
                )
              ]
              spids: [3984]
            )
            (command.Case
              to_match: {(DQ ($ VSub_DollarName '$cmd'))}
              arms: [
                (case_arm
                  pat_list: [{(skip)} {(start)} {(terms)}]
                  spids: [3999 4004 4006 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.AndOr
                              ops: [Op_DAmp Op_DAmp]
                              children: [
                                (C {(test)} {(-s)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_TERMS))})
                                (C {(test)} {(DQ ($ VSub_DollarName '$cmd'))} 
                                  {(KW_Bang '!') (Lit_Other '=')} {(DQ ($ VSub_DollarName '$TERM_BAD'))}
                                )
                                (C {(test)} {(DQ ($ VSub_DollarName '$cmd'))} 
                                  {(KW_Bang '!') (Lit_Other '=')} {(DQ ($ VSub_DollarName '$TERM_GOOD'))}
                                )
                              ]
                            )
                          ]
                          action: [
                            (C {(die)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ ("Invalid command: you're currently in a ") 
                                                (word_part.EscapedLiteralPart
                                                  token: <Lit_EscapedChar '\\$'>
                                                ) (TERM_BAD/) (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) ('TERM_GOOD bisect.')
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [4061 4071]
                                  )
                                )
                              }
                            )
                          ]
                          spids: [16777215 4055]
                        )
                      ]
                      spids: [16777215 4075]
                    )
                    (command.Case
                      to_match: {(DQ ($ VSub_DollarName '$cmd'))}
                      arms: [
                        (case_arm
                          pat_list: [{(bad)} {(good)}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Pipeline
                                      children: [
                                        (C {(test)} {(-s)} 
                                          {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_TERMS))}
                                        )
                                      ]
                                      negated: T
                                    )
                                  ]
                                  action: [(C {(write_terms)} {(bad)} {(good)})]
                                  spids: [16777215 4107]
                                )
                              ]
                              spids: [16777215 4117]
                            )
                          ]
                          spids: [4087 4090 4120 16777215]
                        )
                        (case_arm
                          pat_list: [{(new)} {(old)}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Pipeline
                                      children: [
                                        (C {(test)} {(-s)} 
                                          {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_TERMS))}
                                        )
                                      ]
                                      negated: T
                                    )
                                  ]
                                  action: [(C {(write_terms)} {(new)} {(old)})]
                                  spids: [16777215 4143]
                                )
                              ]
                              spids: [16777215 4153]
                            )
                          ]
                          spids: [4123 4126 4156 16777215]
                        )
                      ]
                      spids: [4078 4084 4159]
                    )
                  ]
                  spids: [4009 4010 4161 16777215]
                )
              ]
              spids: [3990 3996 4164]
            )
          ]
          spids: [3981]
        )
      spids: [3976 3980]
    )
    (command.FuncDef
      name: bisect_voc
      body: 
        (command.BraceGroup
          children: [
            (command.Case
              to_match: {(DQ ($ VSub_Number '$1'))}
              arms: [
                (case_arm
                  pat_list: [{(bad)}]
                  action: [(C {(echo)} {(DQ ('bad|new'))})]
                  spids: [4186 4187 4195 16777215]
                )
                (case_arm
                  pat_list: [{(good)}]
                  action: [(C {(echo)} {(DQ ('good|old'))})]
                  spids: [4198 4199 4207 16777215]
                )
              ]
              spids: [4177 4183 4210]
            )
          ]
          spids: [4174]
        )
      spids: [4169 4173]
    )
    (command.FuncDef
      name: bisect_terms
      body: 
        (command.BraceGroup
          children: [
            (C {(get_terms)})
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Pipeline
                      children: [
                        (C {(test)} {(-s)} {(DQ ($ VSub_DollarName '$GIT_DIR') (/BISECT_TERMS))})
                      ]
                      negated: T
                    )
                  ]
                  action: [
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [(C {(gettext)} {(DQ ('no terms defined'))})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [4246 4252]
                          )
                        )
                      }
                    )
                  ]
                  spids: [16777215 4240]
                )
              ]
              spids: [16777215 4256]
            )
            (command.Case
              to_match: {(DQ ($ VSub_Pound '$#'))}
              arms: [
                (case_arm
                  pat_list: [{(0)}]
                  action: [
                    (C {(gettextln)} 
                      {
                        (DQ ('Your current terms are ') ($ VSub_DollarName '$TERM_GOOD') 
                          (' for the old state\n') ('and ') ($ VSub_DollarName '$TERM_BAD') (' for the new state.')
                        )
                      }
                    )
                  ]
                  spids: [4268 4269 4284 16777215]
                )
                (case_arm
                  pat_list: [{(1)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:arg spids:[4291])
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                          spids: [4291]
                        )
                      ]
                      spids: [4291]
                    )
                    (command.Case
                      to_match: {(DQ ($ VSub_DollarName '$arg'))}
                      arms: [
                        (case_arm
                          pat_list: [{(--term-good)} {(--term-old)}]
                          action: [
                            (C {(printf)} {(SQ <'%s\\n'>)} {(DQ ($ VSub_DollarName '$TERM_GOOD'))})
                          ]
                          spids: [4304 4307 4321 16777215]
                        )
                        (case_arm
                          pat_list: [{(--term-bad)} {(--term-new)}]
                          action: [
                            (C {(printf)} {(SQ <'%s\\n'>)} {(DQ ($ VSub_DollarName '$TERM_BAD'))})
                          ]
                          spids: [4324 4327 4341 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [
                            (C {(die)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ ('invalid argument ') 
                                                (word_part.EscapedLiteralPart
                                                  token: <Lit_EscapedChar '\\$'>
                                                ) ("arg for 'git bisect terms'.\n") 
                                                (
'Supported options are: --term-good|--term-old and --term-bad|--term-new.'
                                                )
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [4351 4360]
                                  )
                                )
                              }
                            )
                          ]
                          spids: [4344 4345 4364 16777215]
                        )
                      ]
                      spids: [4295 4301 4367]
                    )
                  ]
                  spids: [4287 4288 4370 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [(C {(usage)})]
                  spids: [4373 4374 4379 16777215]
                )
              ]
              spids: [4259 4265 4382]
            )
          ]
          spids: [4220]
        )
      spids: [4215 4219]
    )
    (command.Case
      to_match: {(DQ ($ VSub_Pound '$#'))}
      arms: [
        (case_arm pat_list:[{(0)}] action:[(C {(usage)})] spids:[4395 4396 4401 16777215])
        (case_arm
          pat_list: [{(Lit_Other '*')}]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:cmd spids:[4407])
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$1'))}
                  spids: [4407]
                )
              ]
              spids: [4407]
            )
            (C {(get_terms)})
            (C {(shift)})
            (command.Case
              to_match: {(DQ ($ VSub_DollarName '$cmd'))}
              arms: [
                (case_arm
                  pat_list: [{(help)}]
                  action: [(C {(git)} {(bisect)} {(-h)})]
                  spids: [4428 4429 4438 16777215]
                )
                (case_arm
                  pat_list: [{(start)}]
                  action: [(C {(bisect_start)} {(DQ ($ VSub_At '$@'))})]
                  spids: [4441 4442 4451 16777215]
                )
                (case_arm
                  pat_list: [
                    {(bad)}
                    {(good)}
                    {(new)}
                    {(old)}
                    {(DQ ($ VSub_DollarName '$TERM_BAD'))}
                    {(DQ ($ VSub_DollarName '$TERM_GOOD'))}
                  ]
                  action: [
                    (C {(bisect_state)} {(DQ ($ VSub_DollarName '$cmd'))} {(DQ ($ VSub_At '$@'))})
                  ]
                  spids: [4454 4469 4482 16777215]
                )
                (case_arm
                  pat_list: [{(skip)}]
                  action: [(C {(bisect_skip)} {(DQ ($ VSub_At '$@'))})]
                  spids: [4485 4486 4495 16777215]
                )
                (case_arm
                  pat_list: [{(next)}]
                  action: [(C {(bisect_next)} {(DQ ($ VSub_At '$@'))})]
                  spids: [4498 4499 4512 16777215]
                )
                (case_arm
                  pat_list: [{(visualize)} {(view)}]
                  action: [(C {(bisect_visualize)} {(DQ ($ VSub_At '$@'))})]
                  spids: [4515 4518 4527 16777215]
                )
                (case_arm
                  pat_list: [{(reset)}]
                  action: [(C {(bisect_reset)} {(DQ ($ VSub_At '$@'))})]
                  spids: [4530 4531 4540 16777215]
                )
                (case_arm
                  pat_list: [{(replay)}]
                  action: [(C {(bisect_replay)} {(DQ ($ VSub_At '$@'))})]
                  spids: [4543 4544 4553 16777215]
                )
                (case_arm
                  pat_list: [{(log)}]
                  action: [(C {(bisect_log)})]
                  spids: [4556 4557 4562 16777215]
                )
                (case_arm
                  pat_list: [{(run)}]
                  action: [(C {(bisect_run)} {(DQ ($ VSub_At '$@'))})]
                  spids: [4565 4566 4575 16777215]
                )
                (case_arm
                  pat_list: [{(terms)}]
                  action: [(C {(bisect_terms)} {(DQ ($ VSub_At '$@'))})]
                  spids: [4578 4579 4588 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [(C {(usage)})]
                  spids: [4591 4592 4597 16777215]
                )
              ]
              spids: [4419 4425 4600]
            )
          ]
          spids: [4403 4404 16777215 4602]
        )
      ]
      spids: [4387 4393 4602]
    )
  ]
)