(command.CommandList
  children: [
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'USAGE='> name:USAGE)
          op: assign_op.Equal
          rhs: {(SQ <'[help|start|bad|good|new|old|terms|skip|next|reset|visualize|replay|log|run]'>)}
          spids: [4]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'LONG_USAGE='> name:LONG_USAGE)
          op: assign_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]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'OPTIONS_SPEC='> name:OPTIONS_SPEC)
          op: assign_op.Equal
          rhs: (rhs_word.Empty)
          spids: [43]
        )
      ]
      redirects: []
    )
    (C {<.>} {<git-sh-setup>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike '_x40='> name:_x40)
          op: assign_op.Equal
          rhs: {(SQ <'[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'>)}
          spids: [50]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike '_x40='> name:_x40)
          op: assign_op.Equal
          rhs: 
            {
              (DQ ($ Id.VSub_DollarName _x40) ($ Id.VSub_DollarName _x40) ($ Id.VSub_DollarName _x40) 
                ($ Id.VSub_DollarName _x40) ($ Id.VSub_DollarName _x40) ($ Id.VSub_DollarName _x40) ($ Id.VSub_DollarName _x40) 
                ($ Id.VSub_DollarName _x40)
              )
            }
          spids: [55]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'TERM_BAD='> name:TERM_BAD)
          op: assign_op.Equal
          rhs: {<bad>}
          spids: [67]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'TERM_GOOD='> name:TERM_GOOD)
          op: assign_op.Equal
          rhs: {<good>}
          spids: [70]
        )
      ]
      redirects: []
    )
    (command.ShFunction
      name: bisect_head
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<test>} {<-f>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_HEAD'>)})
                      ]
                    )
                  action: [(C {<echo>} {<BISECT_HEAD>})]
                  spids: [81 93]
                )
              ]
              else_action: [(C {<echo>} {<HEAD>})]
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: bisect_autostart
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} {<-s>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_START'>)})
                (BraceGroup
                  left: <Id.Lit_LBrace '{'>
                  children: [
                    (command.Simple
                      words: [
                        {<gettextln>}
                        {
                          (DQ <'You need to start by '> 
                            (word_part.EscapedLiteral
                              token: <Id.Lit_EscapedChar '\\"'>
                              ch: '"'
                            ) <'git bisect start'> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"')
                          )
                        }
                      ]
                      redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                      more_env: []
                      do_fork: T
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: (condition.Shell commands:[(C {<test>} {<-t>} {<0>})])
                          action: [
                            (command.Simple
                              words: [{<gettext>} {(DQ <'Do you want me to do it for you [Y/n]? '>)}]
                              redirects: [
                                (redir
                                  op: <Id.Redir_GreatAnd '>&'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {<2>}
                                )
                              ]
                              more_env: []
                              do_fork: T
                            )
                            (C {<read>} {<yesno>})
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_DollarName yesno))}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {<Id.Lit_LBracket '['> <Nn> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>}
                                  ]
                                  action: [(command.ControlFlow token:<Id.ControlFlow_Exit exit>)]
                                  spids: [196 200 205 -1]
                                )
                              ]
                              redirects: []
                            )
                            (C {<bisect_start>})
                          ]
                          spids: [148 157]
                        )
                      ]
                      else_action: [
                        (command.ControlFlow
                          token: <Id.ControlFlow_Exit exit>
                          arg_word: {<1>}
                        )
                      ]
                      redirects: []
                    )
                  ]
                  redirects: []
                  right: <Id.Lit_RBrace '}'>
                )
              ]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: bisect_start
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: 
                    (sh_lhs_expr.Name
                      left: <Id.Lit_VarLike 'has_double_dash='>
                      name: has_double_dash
                    )
                  op: assign_op.Equal
                  rhs: {<0>}
                  spids: [249]
                )
              ]
              redirects: []
            )
            (command.ForEach
              iter_names: [arg]
              iterable: (for_iter.Args)
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName arg))}
                      arms: [
                        (case_arm
                          pat_list: [{<-->}]
                          action: [
                            (command.Sentence
                              child: 
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: 
                                        (sh_lhs_expr.Name
                                          left: <Id.Lit_VarLike 'has_double_dash='>
                                          name: has_double_dash
                                        )
                                      op: assign_op.Equal
                                      rhs: {<1>}
                                      spids: [272]
                                    )
                                  ]
                                  redirects: []
                                )
                              terminator: <Id.Op_Semi _>
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [269 270 278 -1]
                        )
                      ]
                      redirects: []
                    )
                  ]
                )
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'orig_args='> name:orig_args)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<git>} {<rev-parse>} {<--sq-quote>} {(DQ ($ Id.VSub_At '@'))})
                        right: <Id.Eof_RParen _>
                      )
                    }
                  spids: [286]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'bad_seen='> name:bad_seen)
                  op: assign_op.Equal
                  rhs: {<0>}
                  spids: [300]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'eval='> name:eval)
                  op: assign_op.Equal
                  rhs: {(SQ )}
                  spids: [304]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: 
                    (sh_lhs_expr.Name
                      left: <Id.Lit_VarLike 'must_write_terms='>
                      name: must_write_terms
                    )
                  op: assign_op.Equal
                  rhs: {<0>}
                  spids: [309]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'revs='> name:revs)
                  op: assign_op.Equal
                  rhs: {(SQ )}
                  spids: [313]
                )
              ]
              redirects: []
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<test>} 
                          {
                            (DQ <z> 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<git>} {<rev-parse>} {<--is-bare-repository>})
                                right: <Id.Eof_RParen _>
                              )
                            )
                          } {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<zfalse>}
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'mode='> name:mode)
                          op: assign_op.Equal
                          rhs: {<--no-checkout>}
                          spids: [342]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [318 339]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'mode='> name:mode)
                      op: assign_op.Equal
                      rhs: {(SQ )}
                      spids: [349]
                    )
                  ]
                  redirects: []
                )
              ]
              redirects: []
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (C {<Id.Lit_LBracket '['>} {($ Id.VSub_Pound '#')} {<-gt>} {<0>} 
                          {<Id.Lit_RBracket ']'>}
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'arg='> name:arg)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_Number 1))}
                          spids: [373]
                        )
                      ]
                      redirects: []
                    )
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName arg))}
                      arms: [
                        (case_arm
                          pat_list: [{<-->}]
                          action: [
                            (C {<shift>})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [388 389 398 -1]
                        )
                        (case_arm
                          pat_list: [{<--no-checkout>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'mode='> name:mode)
                                  op: assign_op.Equal
                                  rhs: {<--no-checkout>}
                                  spids: [405]
                                )
                              ]
                              redirects: []
                            )
                            (C {<shift>})
                          ]
                          spids: [401 402 411 -1]
                        )
                        (case_arm
                          pat_list: [{<--term-good>} {<--term-old>}]
                          action: [
                            (C {<shift>})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'must_write_terms='>
                                      name: must_write_terms
                                    )
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [423]
                                )
                              ]
                              redirects: []
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'TERM_GOOD='>
                                      name: TERM_GOOD
                                    )
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_Number 1)}
                                  spids: [427]
                                )
                              ]
                              redirects: []
                            )
                            (C {<shift>})
                          ]
                          spids: [414 417 433 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<--term-good> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}
                            {<--term-old> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'must_write_terms='>
                                      name: must_write_terms
                                    )
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [446]
                                )
                              ]
                              redirects: []
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'TERM_GOOD='>
                                      name: TERM_GOOD
                                    )
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (braced_var_sub
                                        left: <Id.Left_DollarBrace '${'>
                                        token: <Id.VSub_Number 1>
                                        var_name: 1
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op: <Id.VOp1_Pound '#'>
                                            arg_word: {<Id.Lit_Other '*'> <'='>}
                                          )
                                        right: <Id.Right_DollarBrace '}'>
                                      )
                                    }
                                  spids: [450]
                                )
                              ]
                              redirects: []
                            )
                            (C {<shift>})
                          ]
                          spids: [436 443 461 -1]
                        )
                        (case_arm
                          pat_list: [{<--term-bad>} {<--term-new>}]
                          action: [
                            (C {<shift>})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'must_write_terms='>
                                      name: must_write_terms
                                    )
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [473]
                                )
                              ]
                              redirects: []
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'TERM_BAD='>
                                      name: TERM_BAD
                                    )
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_Number 1)}
                                  spids: [477]
                                )
                              ]
                              redirects: []
                            )
                            (C {<shift>})
                          ]
                          spids: [464 467 483 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<--term-bad> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}
                            {<--term-new> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'must_write_terms='>
                                      name: must_write_terms
                                    )
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [496]
                                )
                              ]
                              redirects: []
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'TERM_BAD='>
                                      name: TERM_BAD
                                    )
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (braced_var_sub
                                        left: <Id.Left_DollarBrace '${'>
                                        token: <Id.VSub_Number 1>
                                        var_name: 1
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op: <Id.VOp1_Pound '#'>
                                            arg_word: {<Id.Lit_Other '*'> <'='>}
                                          )
                                        right: <Id.Right_DollarBrace '}'>
                                      )
                                    }
                                  spids: [500]
                                )
                              ]
                              redirects: []
                            )
                            (C {<shift>})
                          ]
                          spids: [486 493 511 -1]
                        )
                        (case_arm
                          pat_list: [{<--> <Id.Lit_Star '*'>}]
                          action: [
                            (C {<die>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<eval_gettext>} 
                                        {
                                          (DQ <'unrecognised option: \''> 
                                            (word_part.EscapedLiteral
                                              token: <Id.Lit_EscapedChar '\\$'>
                                              ch: '$'
                                            ) <'arg\''>
                                          )
                                        }
                                      )
                                    right: <Id.Eof_RParen _>
                                  )
                                )
                              }
                            )
                          ]
                          spids: [514 516 533 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'rev='> name:rev)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (C {<git>} {<rev-parse>} {<-q>} {<--verify>} 
                                                {(DQ ($ Id.VSub_DollarName arg) <'^{commit}'>)}
                                              )
                                            right: <Id.Eof_RParen _>
                                          )
                                        }
                                      spids: [540]
                                    )
                                  ]
                                  redirects: []
                                )
                                (BraceGroup
                                  left: <Id.Lit_LBrace '{'>
                                  children: [
                                    (command.AndOr
                                      ops: [Id.Op_DAmp]
                                      children: [
                                        (C {<test>} {($ Id.VSub_DollarName has_double_dash)} {<-eq>} 
                                          {<1>}
                                        )
                                        (C {<die>} 
                                          {
                                            (DQ 
                                              (command_sub
                                                left_token: <Id.Left_DollarParen '$('>
                                                child: 
                                                  (C {<eval_gettext>} 
                                                    {
                                                      (DQ <'\''> 
                                                        (word_part.EscapedLiteral
                                                          token: <Id.Lit_EscapedChar '\\$'>
                                                          ch: '$'
                                                        ) <'arg\' does not appear to be a valid revision'>
                                                      )
                                                    }
                                                  )
                                                right: <Id.Eof_RParen _>
                                              )
                                            )
                                          }
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Break break>
                                    )
                                  ]
                                  redirects: []
                                  right: <Id.Lit_RBrace '}'>
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'revs='> name:revs)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ ($ Id.VSub_DollarName revs) <' '> ($ Id.VSub_DollarName rev))
                                    }
                                  spids: [593]
                                )
                              ]
                              redirects: []
                            )
                            (C {<shift>})
                          ]
                          spids: [536 537 604 -1]
                        )
                      ]
                      redirects: []
                    )
                  ]
                )
              redirects: []
            )
            (command.ForEach
              iter_names: [rev]
              iterable: (for_iter.Words words:[{($ Id.VSub_DollarName revs)}])
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: 
                            (sh_lhs_expr.Name
                              left: <Id.Lit_VarLike 'must_write_terms='>
                              name: must_write_terms
                            )
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [646]
                        )
                      ]
                      redirects: []
                    )
                    (command.Case
                      to_match: {($ Id.VSub_DollarName bad_seen)}
                      arms: [
                        (case_arm
                          pat_list: [{<0>}]
                          action: [
                            (command.Sentence
                              child: 
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: 
                                        (sh_lhs_expr.Name
                                          left: <Id.Lit_VarLike 'state='>
                                          name: state
                                        )
                                      op: assign_op.Equal
                                      rhs: {($ Id.VSub_DollarName TERM_BAD)}
                                      spids: [661]
                                    )
                                  ]
                                  redirects: []
                                )
                              terminator: <Id.Op_Semi _>
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'bad_seen='>
                                      name: bad_seen
                                    )
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [666]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [658 659 669 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'state='> name:state)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName TERM_GOOD)}
                                  spids: [675]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [672 673 678 -1]
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'eval='> name:eval)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ ($ Id.VSub_DollarName eval) <' bisect_write \''> 
                                ($ Id.VSub_DollarName state) <'\' \''> ($ Id.VSub_DollarName rev) <'\' \'nolog\' &&'>
                              )
                            }
                          spids: [684]
                        )
                      ]
                      redirects: []
                    )
                  ]
                )
              redirects: []
            )
            (command.AndOr
              ops: [Id.Op_DPipe Id.Op_DPipe]
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'head='> name:head)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (command.Simple
                                words: [{<git>} {<symbolic-ref>} {<-q>} {<HEAD>}]
                                redirects: []
                                more_env: [
                                  (env_pair
                                    name: GIT_DIR
                                    val: {(DQ ($ Id.VSub_DollarName GIT_DIR))}
                                    spids: [712]
                                  )
                                ]
                                do_fork: T
                              )
                            right: <Id.Eof_RParen _>
                          )
                        }
                      spids: [710]
                    )
                  ]
                  redirects: []
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'head='> name:head)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (command.Simple
                                words: [{<git>} {<rev-parse>} {<--verify>} {<HEAD>}]
                                redirects: []
                                more_env: [
                                  (env_pair
                                    name: GIT_DIR
                                    val: {(DQ ($ Id.VSub_DollarName GIT_DIR))}
                                    spids: [731]
                                  )
                                ]
                                do_fork: T
                              )
                            right: <Id.Eof_RParen _>
                          )
                        }
                      spids: [729]
                    )
                  ]
                  redirects: []
                )
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<gettext>} {(DQ <'Bad HEAD - I need a HEAD'>)})
                        right: <Id.Eof_RParen _>
                      )
                    )
                  }
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'start_head='> name:start_head)
                  op: assign_op.Equal
                  rhs: {(SQ )}
                  spids: [774]
                )
              ]
              redirects: []
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<test>} {<-s>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_START'>)})
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'start_head='> name:start_head)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<cat>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_START'>)})
                                right: <Id.Eof_RParen _>
                              )
                            }
                          spids: [798]
                        )
                      ]
                      redirects: []
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<test>} {(DQ <z> ($ Id.VSub_DollarName mode))} 
                                  {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ <z--no-checkout>)}
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<git>} {<checkout>} {(DQ ($ Id.VSub_DollarName start_head))} {<-->})
                                (C {<die>} 
                                  {
                                    (DQ 
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<eval_gettext>} 
                                            {
                                              (DQ <'Checking out \''> 
                                                (word_part.EscapedLiteral
                                                  token: <Id.Lit_EscapedChar '\\$'>
                                                  ch: '$'
                                                ) <'start_head\' failed. Try \'git bisect reset <valid-branch>\'.'>
                                              )
                                            }
                                          )
                                        right: <Id.Eof_RParen _>
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                          spids: [809 826]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                  ]
                  spids: [779 791]
                )
              ]
              else_action: [
                (command.Case
                  to_match: {(DQ ($ Id.VSub_DollarName head))}
                  arms: [
                    (case_arm
                      pat_list: [{<'refs/heads/'> <Id.Lit_Star '*'>} {($ Id.VSub_DollarName _x40)}]
                      action: [
                        (command.AndOr
                          ops: [Id.Op_DAmp]
                          children: [
                            (C {<Id.Lit_LBracket '['>} {<-s>} 
                              {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/head-name'>)} {<Id.Lit_RBracket ']'>}
                            )
                            (C {<die>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: (C {<gettext>} {(DQ <'won\'t bisect on cg-seek\'ed tree'>)})
                                    right: <Id.Eof_RParen _>
                                  )
                                )
                              }
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'start_head='>
                                  name: start_head
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ 
                                    (braced_var_sub
                                      left: <Id.Left_DollarBrace '${'>
                                      token: <Id.VSub_Name head>
                                      var_name: head
                                      suffix_op: 
                                        (suffix_op.Unary
                                          op: <Id.VOp1_Pound '#'>
                                          arg_word: 
                                            {<refs> <Id.Lit_Slash '/'> <heads> <Id.Lit_Slash '/'>}
                                        )
                                      right: <Id.Right_DollarBrace '}'>
                                    )
                                  )
                                }
                              spids: [922]
                            )
                          ]
                          redirects: []
                        )
                      ]
                      spids: [876 880 935 -1]
                    )
                    (case_arm
                      pat_list: [{<Id.Lit_Star '*'>}]
                      action: [
                        (C {<die>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<gettext>} {(DQ <'Bad HEAD - strange symbolic ref'>)})
                                right: <Id.Eof_RParen _>
                              )
                            )
                          }
                        )
                      ]
                      spids: [938 939 955 -1]
                    )
                  ]
                  redirects: []
                )
              ]
              redirects: []
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<bisect_clean_state>})
                (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
              ]
            )
            (C {<trap>} {(SQ <bisect_clean_state>)} {<0>})
            (C {<trap>} {(SQ <'exit 255'>)} {<1>} {<2>} {<3>} {<15>})
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DPipe]
              children: [
                (command.Simple
                  words: [{<echo>} {(DQ ($ Id.VSub_DollarName start_head))}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_START'>)}
                    )
                  ]
                  more_env: []
                  do_fork: T
                )
                (BraceGroup
                  left: <Id.Lit_LBrace '{'>
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<test>} {(DQ <z> ($ Id.VSub_DollarName mode))} 
                          {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ <z--no-checkout>)}
                        )
                        (C {<git>} {<update-ref>} {<--no-deref>} {<BISECT_HEAD>} 
                          {(DQ ($ Id.VSub_DollarName start_head))}
                        )
                      ]
                    )
                  ]
                  redirects: []
                  right: <Id.Lit_RBrace '}'>
                )
                (command.Simple
                  words: [{<git>} {<rev-parse>} {<--sq-quote>} {(DQ ($ Id.VSub_At '@'))}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_NAMES'>)}
                    )
                  ]
                  more_env: []
                  do_fork: T
                )
                (C {<eval>} {(DQ ($ Id.VSub_DollarName eval) <' true'>)})
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (C {<test>} {($ Id.VSub_DollarName must_write_terms)} {<-eq>} {<1>})
                          ]
                        )
                      action: [
                        (C {<write_terms>} {(DQ ($ Id.VSub_DollarName TERM_BAD))} 
                          {(DQ ($ Id.VSub_DollarName TERM_GOOD))}
                        )
                      ]
                      spids: [1131 1142]
                    )
                  ]
                  else_action: []
                  redirects: []
                )
                (command.Simple
                  words: [{<echo>} {(DQ <'git bisect start'> ($ Id.VSub_DollarName orig_args))}]
                  redirects: [
                    (redir
                      op: <Id.Redir_DGreat '>>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_LOG'>)}
                    )
                  ]
                  more_env: []
                  do_fork: T
                )
                (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
              ]
            )
            (C {<bisect_auto_next>})
            (C {<trap>} {(SQ <->)} {<0>})
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: bisect_write
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'state='> name:state)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number 1))}
                  spids: [1213]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'rev='> name:rev)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number 2))}
                  spids: [1219]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'nolog='> name:nolog)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number 3))}
                  spids: [1225]
                )
              ]
              redirects: []
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName state))}
              arms: [
                (case_arm
                  pat_list: [{(DQ ($ Id.VSub_DollarName TERM_BAD))}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'tag='> name:tag)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName state))}
                          spids: [1246]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [1240 1243 1251 -1]
                )
                (case_arm
                  pat_list: [{(DQ ($ Id.VSub_DollarName TERM_GOOD))} {<skip>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'tag='> name:tag)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName state)) <-> (DQ ($ Id.VSub_DollarName rev))}
                          spids: [1262]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [1254 1259 1271 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<eval_gettext>} 
                                {
                                  (DQ <'Bad bisect_write argument: '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                      ch: '$'
                                    ) <state>
                                  )
                                }
                              )
                            right: <Id.Eof_RParen _>
                          )
                        )
                      }
                    )
                  ]
                  spids: [1274 1275 1292 -1]
                )
              ]
              redirects: []
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<git>} {<update-ref>} {(DQ <'refs/bisect/'> ($ Id.VSub_DollarName tag))} 
                  {(DQ ($ Id.VSub_DollarName rev))}
                )
                (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
              ]
            )
            (command.Simple
              words: [
                {<echo>}
                {
                  (DQ <'# '> ($ Id.VSub_DollarName state) <': '> 
                    (command_sub
                      left_token: <Id.Left_DollarParen '$('>
                      child: (C {<git>} {<show-branch>} {($ Id.VSub_DollarName rev)})
                      right: <Id.Eof_RParen _>
                    )
                  )
                }
              ]
              redirects: [
                (redir
                  op: <Id.Redir_DGreat '>>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_LOG'>)}
                )
              ]
              more_env: []
              do_fork: T
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName nolog))})
                (command.Simple
                  words: [
                    {<echo>}
                    {
                      (DQ <'git bisect '> ($ Id.VSub_DollarName state) <' '> ($ Id.VSub_DollarName rev))
                    }
                  ]
                  redirects: [
                    (redir
                      op: <Id.Redir_DGreat '>>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_LOG'>)}
                    )
                  ]
                  more_env: []
                  do_fork: T
                )
              ]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: is_expected_rev
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-f>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_EXPECTED_REV'>)})
                (C {<test>} {(DQ ($ Id.VSub_Number 1))} {<Id.Lit_Equals '='>} 
                  {
                    (command_sub
                      left_token: <Id.Left_DollarParen '$('>
                      child: (C {<cat>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_EXPECTED_REV'>)})
                      right: <Id.Eof_RParen _>
                    )
                  }
                )
              ]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: check_expected_revs
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ForEach
              iter_names: [_rev]
              iterable: (for_iter.Words words:[{(DQ ($ Id.VSub_At '@'))}])
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Pipeline
                                  children: [(C {<is_expected_rev>} {(DQ ($ Id.VSub_DollarName _rev))})]
                                  negated: T
                                  stderr_indices: []
                                )
                              ]
                            )
                          action: [
                            (C {<rm>} {<-f>} 
                              {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_ANCESTORS_OK'>)}
                            )
                            (C {<rm>} {<-f>} 
                              {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_EXPECTED_REV'>)}
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                            )
                          ]
                          spids: [1426 1437]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                  ]
                )
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: bisect_skip
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'all='> name:all)
                  op: assign_op.Equal
                  rhs: {(SQ )}
                  spids: [1478]
                )
              ]
              redirects: []
            )
            (command.ForEach
              iter_names: [arg]
              iterable: (for_iter.Words words:[{(DQ ($ Id.VSub_At '@'))}])
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName arg))}
                      arms: [
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'> <..> <Id.Lit_Star '*'>}]
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'revs='> name:revs)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (C {<git>} {<rev-list>} {(DQ ($ Id.VSub_DollarName arg))})
                                            right: <Id.Eof_RParen _>
                                          )
                                        }
                                      spids: [1512]
                                    )
                                  ]
                                  redirects: []
                                )
                                (C {<die>} 
                                  {
                                    (DQ 
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<eval_gettext>} 
                                            {
                                              (DQ <'Bad rev input: '> 
                                                (word_part.EscapedLiteral
                                                  token: <Id.Lit_EscapedChar '\\$'>
                                                  ch: '$'
                                                ) <arg>
                                              )
                                            }
                                          )
                                        right: <Id.Eof_RParen _>
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                          spids: [1506 1509 1539 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'revs='> name:revs)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<git>} {<rev-parse>} {<--sq-quote>} 
                                            {(DQ ($ Id.VSub_DollarName arg))}
                                          )
                                        right: <Id.Eof_RParen _>
                                      )
                                    }
                                  spids: [1546]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [1542 1543 1559 -1]
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'all='> name:all)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName all) <' '> ($ Id.VSub_DollarName revs))}
                          spids: [1565]
                        )
                      ]
                      redirects: []
                    )
                  ]
                )
              redirects: []
            )
            (C {<eval>} {<bisect_state>} {(SQ <skip>)} {($ Id.VSub_DollarName all)})
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: bisect_state
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (C {<bisect_autostart>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'state='> name:state)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 1)}
                  spids: [1599]
                )
              ]
              redirects: []
            )
            (C {<check_and_set_terms>} {($ Id.VSub_DollarName state)})
            (command.Case
              to_match: {(DQ ($ Id.VSub_Pound '#') <','> ($ Id.VSub_DollarName state))}
              arms: [
                (case_arm
                  pat_list: [{<0> <Id.Lit_Comma ','> <Id.Lit_Star '*'>}]
                  action: [
                    (C {<die>} {(DQ <'Please call \'bisect_state\' with at least one argument.'>)})
                  ]
                  spids: [1619 1622 1631 -1]
                )
                (case_arm
                  pat_list: [
                    {<1> <Id.Lit_Comma ','> (DQ ($ Id.VSub_DollarName TERM_BAD))}
                    {<1> <Id.Lit_Comma ','> (DQ ($ Id.VSub_DollarName TERM_GOOD))}
                    {<1> <Id.Lit_Comma ','> <skip>}
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: 
                            (sh_lhs_expr.Name
                              left: <Id.Lit_VarLike 'bisected_head='>
                              name: bisected_head
                            )
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<bisect_head>})
                                right: <Id.Eof_RParen _>
                              )
                            }
                          spids: [1652]
                        )
                      ]
                      redirects: []
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'rev='> name:rev)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<git>} {<rev-parse>} {<--verify>} 
                                        {(DQ ($ Id.VSub_DollarName bisected_head))}
                                      )
                                    right: <Id.Eof_RParen _>
                                  )
                                }
                              spids: [1658]
                            )
                          ]
                          redirects: []
                        )
                        (C {<die>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<eval_gettext>} 
                                    {
                                      (DQ <'Bad rev input: '> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\$'>
                                          ch: '$'
                                        ) <bisected_head>
                                      )
                                    }
                                  )
                                right: <Id.Eof_RParen _>
                              )
                            )
                          }
                        )
                      ]
                    )
                    (C {<bisect_write>} {(DQ ($ Id.VSub_DollarName state))} 
                      {(DQ ($ Id.VSub_DollarName rev))}
                    )
                    (C {<check_expected_revs>} {(DQ ($ Id.VSub_DollarName rev))})
                  ]
                  spids: [1634 1649 1706 -1]
                )
                (case_arm
                  pat_list: [
                    {<2> <Id.Lit_Comma ','> (DQ ($ Id.VSub_DollarName TERM_BAD))}
                    {<Id.Lit_Star '*'> <Id.Lit_Comma ','> (DQ ($ Id.VSub_DollarName TERM_GOOD))}
                    {<Id.Lit_Star '*'> <Id.Lit_Comma ','> <skip>}
                  ]
                  action: [
                    (C {<shift>})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'hash_list='> name:hash_list)
                          op: assign_op.Equal
                          rhs: {(SQ )}
                          spids: [1730]
                        )
                      ]
                      redirects: []
                    )
                    (command.ForEach
                      iter_names: [rev]
                      iterable: (for_iter.Words words:[{(DQ ($ Id.VSub_At '@'))}])
                      body: 
                        (command.DoGroup
                          children: [
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'sha='> name:sha)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (C {<git>} {<rev-parse>} {<--verify>} 
                                                {(DQ ($ Id.VSub_DollarName rev) <'^{commit}'>)}
                                              )
                                            right: <Id.Eof_RParen _>
                                          )
                                        }
                                      spids: [1749]
                                    )
                                  ]
                                  redirects: []
                                )
                                (C {<die>} 
                                  {
                                    (DQ 
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<eval_gettext>} 
                                            {
                                              (DQ <'Bad rev input: '> 
                                                (word_part.EscapedLiteral
                                                  token: <Id.Lit_EscapedChar '\\$'>
                                                  ch: '$'
                                                ) <rev>
                                              )
                                            }
                                          )
                                        right: <Id.Eof_RParen _>
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'hash_list='>
                                      name: hash_list
                                    )
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ ($ Id.VSub_DollarName hash_list) <' '> 
                                        ($ Id.VSub_DollarName sha)
                                      )
                                    }
                                  spids: [1781]
                                )
                              ]
                              redirects: []
                            )
                          ]
                        )
                      redirects: []
                    )
                    (command.ForEach
                      iter_names: [rev]
                      iterable: (for_iter.Words words:[{($ Id.VSub_DollarName hash_list)}])
                      body: 
                        (command.DoGroup
                          children: [
                            (C {<bisect_write>} {(DQ ($ Id.VSub_DollarName state))} 
                              {(DQ ($ Id.VSub_DollarName rev))}
                            )
                          ]
                        )
                      redirects: []
                    )
                    (C {<check_expected_revs>} {($ Id.VSub_DollarName hash_list)})
                  ]
                  spids: [1709 1724 1822 -1]
                )
                (case_arm
                  pat_list: [
                    {<Id.Lit_Star '*'> <Id.Lit_Comma ','> (DQ ($ Id.VSub_DollarName TERM_BAD))}
                  ]
                  action: [
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<eval_gettext>} 
                                {
                                  (DQ <'\'git bisect '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                      ch: '$'
                                    ) <'TERM_BAD\' can take only one argument.'>
                                  )
                                }
                              )
                            right: <Id.Eof_RParen _>
                          )
                        )
                      }
                    )
                  ]
                  spids: [1825 1830 1847 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [(C {<usage>})]
                  spids: [1850 1851 1856 -1]
                )
              ]
              redirects: []
            )
            (C {<bisect_auto_next>})
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: bisect_next_check
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'missing_good='> name:missing_good)
                  op: assign_op.Equal
                  rhs: (rhs_word.Empty)
                  spids: [1874]
                )
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'missing_bad='> name:missing_bad)
                  op: assign_op.Equal
                  rhs: (rhs_word.Empty)
                  spids: [1876]
                )
              ]
              redirects: []
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<git>} {<show-ref>} {<-q>} {<--verify>} 
                  {<'refs/bisect/'> ($ Id.VSub_DollarName TERM_BAD)}
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'missing_bad='> name:missing_bad)
                      op: assign_op.Equal
                      rhs: {<t>}
                      spids: [1892]
                    )
                  ]
                  redirects: []
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} {<-n>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C {<git>} {<for-each-ref>} 
                            {(DQ <'refs/bisect/'> ($ Id.VSub_DollarName TERM_GOOD) <'-*'>)}
                          )
                        right: <Id.Eof_RParen _>
                      )
                    )
                  }
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'missing_good='> name:missing_good)
                      op: assign_op.Equal
                      rhs: {<t>}
                      spids: [1916]
                    )
                  ]
                  redirects: []
                )
              ]
            )
            (command.Case
              to_match: 
                {
                  (DQ ($ Id.VSub_DollarName missing_good) <','> ($ Id.VSub_DollarName missing_bad) <','> 
                    ($ Id.VSub_Number 1)
                  )
                }
              arms: [
                (case_arm
                  pat_list: [{<Id.Lit_Comma ','> <Id.Lit_Comma ','> <Id.Lit_Star '*'>}]
                  action: [
                    (C {<Id.Lit_Colon ':'>} {<have>} {<both>} {($ Id.VSub_DollarName TERM_GOOD)} {<and>} 
                      {($ Id.VSub_DollarName TERM_BAD)} {<->} {<ok>}
                    )
                  ]
                  spids: [1934 1937 1957 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'> <Id.Lit_Comma ','>}]
                  action: [(C {<false>})]
                  spids: [1960 1962 1972 -1]
                )
                (case_arm
                  pat_list: [
                    {<t> <Id.Lit_Comma ','> <Id.Lit_Comma ','> (DQ ($ Id.VSub_DollarName TERM_GOOD))}
                  ]
                  action: [
                    (command.Simple
                      words: [
                        {<eval_gettextln>}
                        {
                          (DQ <'Warning: bisecting only with a '> 
                            (word_part.EscapedLiteral
                              token: <Id.Lit_EscapedChar '\\$'>
                              ch: '$'
                            ) <'TERM_BAD commit.'>
                          )
                        }
                      ]
                      redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                      more_env: []
                      do_fork: T
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: (condition.Shell commands:[(C {<test>} {<-t>} {<0>})])
                          action: [
                            (command.Simple
                              words: [{<gettext>} {(DQ <'Are you sure [Y/n]? '>)}]
                              redirects: [
                                (redir
                                  op: <Id.Redir_GreatAnd '>&'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {<2>}
                                )
                              ]
                              more_env: []
                              do_fork: T
                            )
                            (C {<read>} {<yesno>})
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_DollarName yesno))}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {<Id.Lit_LBracket '['> <Nn> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>}
                                  ]
                                  action: [
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Exit exit>
                                      arg_word: {<1>}
                                    )
                                  ]
                                  spids: [2051 2055 2061 -1]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [2004 2013]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                    (C {<Id.Lit_Colon ':'>} {<bisect>} {<without>} 
                      {($ Id.VSub_DollarName TERM_GOOD) <Id.Lit_TDot ...>}
                    )
                  ]
                  spids: [1975 1981 2079 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'bad_syn='> name:bad_syn)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<bisect_voc>} {<bad>})
                                right: <Id.Eof_RParen _>
                              )
                            }
                          spids: [2086]
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'good_syn='> name:good_syn)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<bisect_voc>} {<good>})
                                right: <Id.Eof_RParen _>
                              )
                            }
                          spids: [2094]
                        )
                      ]
                      redirects: []
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<test>} {<-s>} 
                                  {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_START'>)}
                                )
                              ]
                            )
                          action: [
                            (command.Simple
                              words: [
                                {<eval_gettextln>}
                                {
                                  (DQ <'You need to give me at least one '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                      ch: '$'
                                    ) <'bad_syn and one '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') 
                                    <'good_syn revision.\n'> <'(You can use '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"') <'git bisect '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                      ch: '$'
                                    ) <bad_syn> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"') <' and '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\"'>
                                      ch: '"'
                                    ) <'git bisect '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') <good_syn> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\"'>
                                      ch: '"'
                                    ) <' for that.)'>
                                  )
                                }
                              ]
                              redirects: [
                                (redir
                                  op: <Id.Redir_GreatAnd '>&'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {<2>}
                                )
                              ]
                              more_env: []
                              do_fork: T
                            )
                          ]
                          spids: [2102 2114]
                        )
                      ]
                      else_action: [
                        (command.Simple
                          words: [
                            {<eval_gettextln>}
                            {
                              (DQ <'You need to start by '> 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\"'>
                                  ch: '"'
                                ) <'git bisect start'> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"') <'.\n'> 
                                <'You then need to give me at least one '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') <'good_syn and one '> 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\$'>
                                  ch: '$'
                                ) <'bad_syn revision.\n'> <'(You can use '> 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\"'>
                                  ch: '"'
                                ) <'git bisect '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') <bad_syn> 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\"'>
                                  ch: '"'
                                ) <' and '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"') <'git bisect '> 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\$'>
                                  ch: '$'
                                ) <good_syn> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"') <' for that.)'>
                              )
                            }
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_GreatAnd '>&'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<2>}
                            )
                          ]
                          more_env: []
                          do_fork: T
                        )
                      ]
                      redirects: []
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {<1>}
                    )
                  ]
                  spids: [2082 2083 2187 -1]
                )
              ]
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: bisect_auto_next
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DPipe]
              children: [(C {<bisect_next_check>}) (C {<bisect_next>}) (C {<Id.Lit_Colon ':'>})]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: bisect_next
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Case
              to_match: {(DQ ($ Id.VSub_Pound '#'))}
              arms: [
                (case_arm pat_list:[{<0>}] action:[] spids:[2230 2231 2233 -1])
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [(C {<usage>})]
                  spids: [2235 2236 2240 -1]
                )
              ]
              redirects: []
            )
            (C {<bisect_autostart>})
            (C {<bisect_next_check>} {($ Id.VSub_DollarName TERM_GOOD)})
            (C {<git>} {<bisect--helper>} {<--next-all>} 
              {
                (command_sub
                  left_token: <Id.Left_DollarParen '$('>
                  child: 
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<test>} {<-f>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_HEAD'>)})
                        (C {<echo>} {<--no-checkout>})
                      ]
                    )
                  right: <Id.Eof_RParen _>
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'res='> name:res)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '?')}
                  spids: [2282]
                )
              ]
              redirects: []
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {($ Id.VSub_DollarName res)} {<-eq>} {<10>})]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'bad_rev='> name:bad_rev)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<git>} {<show-ref>} {<--hash>} {<--verify>} 
                                    {<'refs/bisect/'> ($ Id.VSub_DollarName TERM_BAD)}
                                  )
                                right: <Id.Eof_RParen _>
                              )
                            }
                          spids: [2305]
                        )
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'bad_commit='> name:bad_commit)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<git>} {<show-branch>} {($ Id.VSub_DollarName bad_rev)})
                                right: <Id.Eof_RParen _>
                              )
                            }
                          spids: [2320]
                        )
                      ]
                      redirects: []
                    )
                    (command.Simple
                      words: [
                        {<echo>}
                        {
                          (DQ <'# first '> ($ Id.VSub_DollarName TERM_BAD) <' commit: '> 
                            ($ Id.VSub_DollarName bad_commit)
                          )
                        }
                      ]
                      redirects: [
                        (redir
                          op: <Id.Redir_DGreat '>>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_LOG'>)}
                        )
                      ]
                      more_env: []
                      do_fork: T
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [2291 2302]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {($ Id.VSub_DollarName res)} {<-eq>} {<2>})]
                    )
                  action: [
                    (command.Simple
                      words: [{<echo>} {(DQ <'# only skipped commits left to test'>)}]
                      redirects: [
                        (redir
                          op: <Id.Redir_DGreat '>>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_LOG'>)}
                        )
                      ]
                      more_env: []
                      do_fork: T
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'good_revs='> name:good_revs)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<git>} {<for-each-ref>} 
                                    {<--format> <Id.Lit_Equals '='> (DQ <'%(objectname)'>)} {(DQ <'refs/bisect/'> ($ Id.VSub_DollarName TERM_GOOD) <'-*'>)}
                                  )
                                right: <Id.Eof_RParen _>
                              )
                            }
                          spids: [2378]
                        )
                      ]
                      redirects: []
                    )
                    (command.ForEach
                      iter_names: [skipped]
                      iterable: 
                        (for_iter.Words
                          words: [
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<git>} {<rev-list>} 
                                    {<'refs/bisect/'> ($ Id.VSub_DollarName TERM_BAD)} {<--not>} {($ Id.VSub_DollarName good_revs)}
                                  )
                                right: <Id.Eof_RParen _>
                              )
                            }
                          ]
                        )
                      body: 
                        (command.DoGroup
                          children: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'skipped_commit='>
                                      name: skipped_commit
                                    )
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<git>} {<show-branch>} {($ Id.VSub_DollarName skipped)})
                                        right: <Id.Eof_RParen _>
                                      )
                                    }
                                  spids: [2421]
                                )
                              ]
                              redirects: []
                            )
                            (command.Simple
                              words: [
                                {<echo>}
                                {
                                  (DQ <'# possible first '> ($ Id.VSub_DollarName TERM_BAD) 
                                    <' commit: '> ($ Id.VSub_DollarName skipped_commit)
                                  )
                                }
                              ]
                              redirects: [
                                (redir
                                  op: <Id.Redir_DGreat '>>'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_LOG'>)}
                                )
                              ]
                              more_env: []
                              do_fork: T
                            )
                          ]
                        )
                      redirects: []
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {($ Id.VSub_DollarName res)}
                    )
                  ]
                  spids: [2351 2362]
                )
              ]
              else_action: []
              redirects: []
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {($ Id.VSub_DollarName res)} {<-ne>} {<0>})
                (command.ControlFlow
                  token: <Id.ControlFlow_Exit exit>
                  arg_word: {($ Id.VSub_DollarName res)}
                )
              ]
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: bisect_visualize
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (C {<bisect_next_check>} {<fail>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {($ Id.VSub_Pound '#')} {<Id.Lit_Equals '='>} {<0>})]
                    )
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (C {<test>} {<-n>} 
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            left: <Id.Left_DollarBrace '${'>
                                            token: <Id.VSub_Name DISPLAY>
                                            var_name: DISPLAY
                                            suffix_op: 
                                              (suffix_op.Unary
                                                op: <Id.VTest_Plus _>
                                                arg_word: {<set>}
                                              )
                                            right: <Id.Right_DollarBrace '}'>
                                          ) 
                                          (braced_var_sub
                                            left: <Id.Left_DollarBrace '${'>
                                            token: <Id.VSub_Name SESSIONNAME>
                                            var_name: SESSIONNAME
                                            suffix_op: 
                                              (suffix_op.Unary
                                                op: <Id.VTest_Plus _>
                                                arg_word: {<set>}
                                              )
                                            right: <Id.Right_DollarBrace '}'>
                                          ) 
                                          (braced_var_sub
                                            left: <Id.Left_DollarBrace '${'>
                                            token: <Id.VSub_Name MSYSTEM>
                                            var_name: MSYSTEM
                                            suffix_op: 
                                              (suffix_op.Unary
                                                op: <Id.VTest_Plus _>
                                                arg_word: {<set>}
                                              )
                                            right: <Id.Right_DollarBrace '}'>
                                          ) 
                                          (braced_var_sub
                                            left: <Id.Left_DollarBrace '${'>
                                            token: <Id.VSub_Name SECURITYSESSIONID>
                                            var_name: SECURITYSESSIONID
                                            suffix_op: 
                                              (suffix_op.Unary
                                                op: <Id.VTest_Plus _>
                                                arg_word: {<set>}
                                              )
                                            right: <Id.Right_DollarBrace '}'>
                                          )
                                        )
                                      }
                                    )
                                    (command.Simple
                                      words: [{<type>} {<gitk>}]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_Great '>'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: {<'/dev/null'>}
                                        )
                                        (redir
                                          op: <Id.Redir_GreatAnd '2>&'>
                                          loc: (redir_loc.Fd fd:2)
                                          arg: {<1>}
                                        )
                                      ]
                                      more_env: []
                                      do_fork: T
                                    )
                                  ]
                                )
                              ]
                            )
                          action: [(C {<set>} {<gitk>})]
                          spids: [2513 2556]
                        )
                      ]
                      else_action: [(C {<set>} {<git>} {<log>})]
                      redirects: []
                    )
                  ]
                  spids: [2499 2510]
                )
              ]
              else_action: [
                (command.Case
                  to_match: {(DQ ($ Id.VSub_Number 1))}
                  arms: [
                    (case_arm
                      pat_list: [{<git> <Id.Lit_Star '*'>} {<tig>}]
                      action: []
                      spids: [2589 2593 2595 -1]
                    )
                    (case_arm
                      pat_list: [{<-> <Id.Lit_Star '*'>}]
                      action: [(C {<set>} {<git>} {<log>} {(DQ ($ Id.VSub_At '@'))})]
                      spids: [2598 2600 2612 -1]
                    )
                    (case_arm
                      pat_list: [{<Id.Lit_Star '*'>}]
                      action: [(C {<set>} {<git>} {(DQ ($ Id.VSub_At '@'))})]
                      spids: [2615 2616 2626 -1]
                    )
                  ]
                  redirects: []
                )
              ]
              redirects: []
            )
            (C {<eval>} {(SQ <'"$@"'>)} {<--bisect>} {<-->} 
              {
                (command_sub
                  left_token: <Id.Left_DollarParen '$('>
                  child: (C {<cat>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_NAMES'>)})
                  right: <Id.Eof_RParen _>
                )
              }
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: bisect_reset
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} {<-s>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_START'>)})
                (BraceGroup
                  left: <Id.Lit_LBrace '{'>
                  children: [
                    (C {<gettextln>} {(DQ <'We are not bisecting.'>)})
                    (command.ControlFlow token:<Id.ControlFlow_Return return>)
                  ]
                  redirects: []
                  right: <Id.Lit_RBrace '}'>
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_Pound '#'))}
              arms: [
                (case_arm
                  pat_list: [{<0>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'branch='> name:branch)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<cat>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_START'>)})
                                right: <Id.Eof_RParen _>
                              )
                            }
                          spids: [2704]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [2701 2702 2714 -1]
                )
                (case_arm
                  pat_list: [{<1>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.Simple
                          words: [
                            {<git>}
                            {<rev-parse>}
                            {<--quiet>}
                            {<--verify>}
                            {(DQ ($ Id.VSub_Number 1) <'^{commit}'>)}
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<'/dev/null'>}
                            )
                          ]
                          more_env: []
                          do_fork: T
                        )
                        (BraceGroup
                          left: <Id.Lit_LBrace '{'>
                          children: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'invalid='>
                                      name: invalid
                                    )
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_Number 1))}
                                  spids: [2741]
                                )
                              ]
                              redirects: []
                            )
                            (C {<die>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<eval_gettext>} 
                                        {
                                          (DQ <'\''> 
                                            (word_part.EscapedLiteral
                                              token: <Id.Lit_EscapedChar '\\$'>
                                              ch: '$'
                                            ) <'invalid\' is not a valid commit'>
                                          )
                                        }
                                      )
                                    right: <Id.Eof_RParen _>
                                  )
                                )
                              }
                            )
                          ]
                          redirects: []
                          right: <Id.Lit_RBrace '}'>
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'branch='> name:branch)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_Number 1))}
                          spids: [2765]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [2717 2718 2770 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [(C {<usage>})]
                  spids: [2773 2774 2779 -1]
                )
              ]
              redirects: []
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.AndOr
                          ops: [Id.Op_DAmp]
                          children: [
                            (command.Pipeline
                              children: [
                                (C {<test>} {<-f>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_HEAD'>)})
                              ]
                              negated: T
                              stderr_indices: []
                            )
                            (command.Pipeline
                              children: [
                                (C {<git>} {<checkout>} {(DQ ($ Id.VSub_DollarName branch))} {<-->})
                              ]
                              negated: T
                              stderr_indices: []
                            )
                          ]
                        )
                      ]
                    )
                  action: [
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<eval_gettext>} 
                                {
                                  (DQ <'Could not check out original HEAD \''> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                      ch: '$'
                                    ) <'branch\'.\n'> <'Try \'git bisect reset <commit>\'.'>
                                  )
                                }
                              )
                            right: <Id.Eof_RParen _>
                          )
                        )
                      }
                    )
                  ]
                  spids: [2786 2814]
                )
              ]
              else_action: []
              redirects: []
            )
            (C {<bisect_clean_state>})
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: bisect_clean_state
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Pipeline
              children: [
                (C {<git>} {<for-each-ref>} 
                  {<--format> <Id.Lit_Equals '='> (SQ <'%(refname) %(objectname)'>)} {<'refs/bisect/'> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\*'> ch:'*')}
                )
                (command.WhileUntil
                  keyword: <Id.KW_While while>
                  cond: (condition.Shell commands:[(C {<read>} {<ref>} {<hash>})])
                  body: 
                    (command.DoGroup
                      children: [
                        (command.AndOr
                          ops: [Id.Op_DPipe]
                          children: [
                            (C {<git>} {<update-ref>} {<-d>} {($ Id.VSub_DollarName ref)} 
                              {($ Id.VSub_DollarName hash)}
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Exit exit>
                            )
                          ]
                        )
                      ]
                    )
                  redirects: []
                )
              ]
              negated: F
              stderr_indices: []
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp]
              children: [
                (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_EXPECTED_REV'>)})
                (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_ANCESTORS_OK'>)})
                (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_LOG'>)})
                (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_NAMES'>)})
                (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_RUN'>)})
                (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_TERMS'>)})
                (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/head-name'>)})
                (C {<git>} {<update-ref>} {<-d>} {<--no-deref>} {<BISECT_HEAD>})
                (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_START'>)})
              ]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: bisect_replay
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'file='> name:file)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number 1))}
                  spids: [3023]
                )
              ]
              redirects: []
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} {(DQ ($ Id.VSub_Pound '#'))} {<-eq>} {<1>})
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<gettext>} {(DQ <'No logfile given'>)})
                        right: <Id.Eof_RParen _>
                      )
                    )
                  }
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} {<-r>} {(DQ ($ Id.VSub_DollarName file))})
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C {<eval_gettext>} 
                            {
                              (DQ <'cannot read '> 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\$'>
                                  ch: '$'
                                ) <'file for replaying'>
                              )
                            }
                          )
                        right: <Id.Eof_RParen _>
                      )
                    )
                  }
                )
              ]
            )
            (C {<bisect_reset>})
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: (condition.Shell commands:[(C {<read>} {<git>} {<bisect>} {<command>} {<rev>})])
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DPipe Id.Op_DPipe]
                      children: [
                        (C {<test>} 
                          {(DQ ($ Id.VSub_DollarName git) <' '> ($ Id.VSub_DollarName bisect))} {<Id.Lit_Equals '='>} {(DQ <'git bisect'>)}
                        )
                        (C {<test>} {(DQ ($ Id.VSub_DollarName git))} {<Id.Lit_Equals '='>} 
                          {(DQ <git-bisect>)}
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Continue continue>
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<test>} {(DQ ($ Id.VSub_DollarName git))} {<Id.Lit_Equals '='>} 
                                  {(DQ <git-bisect>)}
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'rev='> name:rev)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName command))}
                                  spids: [3149]
                                )
                              ]
                              redirects: []
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'command='>
                                      name: command
                                    )
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName bisect))}
                                  spids: [3155]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [3131 3146]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                    (C {<get_terms>})
                    (C {<check_and_set_terms>} {(DQ ($ Id.VSub_DollarName command))})
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName command))}
                      arms: [
                        (case_arm
                          pat_list: [{<start>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'cmd='> name:cmd)
                                  op: assign_op.Equal
                                  rhs: {(DQ <'bisect_start '> ($ Id.VSub_DollarName rev))}
                                  spids: [3187]
                                )
                              ]
                              redirects: []
                            )
                            (C {<eval>} {(DQ ($ Id.VSub_DollarName cmd))})
                          ]
                          spids: [3183 3184 3200 -1]
                        )
                        (case_arm
                          pat_list: [
                            {(DQ ($ Id.VSub_DollarName TERM_GOOD))}
                            {(DQ ($ Id.VSub_DollarName TERM_BAD))}
                            {<skip>}
                          ]
                          action: [
                            (C {<bisect_write>} {(DQ ($ Id.VSub_DollarName command))} 
                              {(DQ ($ Id.VSub_DollarName rev))}
                            )
                          ]
                          spids: [3203 3212 3225 -1]
                        )
                        (case_arm
                          pat_list: [{<terms>}]
                          action: [(C {<bisect_terms>} {($ Id.VSub_DollarName rev)})]
                          spids: [3228 3229 3236 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (C {<die>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: (C {<gettext>} {(DQ <'?? what are you talking about?'>)})
                                    right: <Id.Eof_RParen _>
                                  )
                                )
                              }
                            )
                          ]
                          spids: [3239 3240 3255 -1]
                        )
                      ]
                      redirects: []
                    )
                  ]
                )
              redirects: [
                (redir
                  op: <Id.Redir_Less '<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: {(DQ ($ Id.VSub_DollarName file))}
                )
              ]
            )
            (C {<bisect_auto_next>})
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: bisect_run
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (C {<bisect_next_check>} {<fail>})
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: (condition.Shell commands:[(C {<true>})])
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'command='> name:command)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_At '@'))}
                          spids: [3296]
                        )
                      ]
                      redirects: []
                    )
                    (C {<eval_gettextln>} 
                      {
                        (DQ <'running '> 
                          (word_part.EscapedLiteral
                            token: <Id.Lit_EscapedChar '\\$'>
                            ch: '$'
                          ) <command>
                        )
                      }
                    )
                    (C {(DQ ($ Id.VSub_At '@'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'res='> name:res)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_QMark '?')}
                          spids: [3316]
                        )
                      ]
                      redirects: []
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<Id.Lit_LBracket '['>} {($ Id.VSub_DollarName res)} {<-lt>} {<0>} 
                                  {<-o>} {($ Id.VSub_DollarName res)} {<-ge>} {<128>} {<Id.Lit_RBracket ']'>}
                                )
                              ]
                            )
                          action: [
                            (command.Simple
                              words: [
                                {<eval_gettextln>}
                                {
                                  (DQ <'bisect run failed:\n'> <'exit code '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                      ch: '$'
                                    ) <'res from \''> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') 
                                    <'command\' is < 0 or >= 128'>
                                  )
                                }
                              ]
                              redirects: [
                                (redir
                                  op: <Id.Redir_GreatAnd '>&'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {<2>}
                                )
                              ]
                              more_env: []
                              do_fork: T
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Exit exit>
                              arg_word: {($ Id.VSub_DollarName res)}
                            )
                          ]
                          spids: [3325 3346]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<Id.Lit_LBracket '['>} {($ Id.VSub_DollarName res)} {<-eq>} {<125>} 
                                  {<Id.Lit_RBracket ']'>}
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'state='> name:state)
                                  op: assign_op.Equal
                                  rhs: {(SQ <skip>)}
                                  spids: [3397]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [3381 3394]
                        )
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<Id.Lit_LBracket '['>} {($ Id.VSub_DollarName res)} {<-gt>} {<0>} 
                                  {<Id.Lit_RBracket ']'>}
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'state='> name:state)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName TERM_BAD))}
                                  spids: [3419]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [3403 3416]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'state='> name:state)
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_DollarName TERM_GOOD))}
                              spids: [3428]
                            )
                          ]
                          redirects: []
                        )
                      ]
                      redirects: []
                    )
                    (command.Subshell
                      child: 
                        (command.Simple
                          words: [{<bisect_state>} {($ Id.VSub_DollarName state)}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_RUN'>)}
                            )
                          ]
                          more_env: []
                          do_fork: T
                        )
                      redirects: []
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'res='> name:res)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_QMark '?')}
                          spids: [3457]
                        )
                      ]
                      redirects: []
                    )
                    (C {<cat>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_RUN'>)})
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Simple
                                  words: [
                                    {<sane_grep>}
                                    {
                                      (DQ <'first '> ($ Id.VSub_DollarName TERM_BAD) 
                                        <' commit could be any of'>
                                      )
                                    }
                                    {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_RUN'>)}
                                  ]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_Great '>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {<'/dev/null'>}
                                    )
                                  ]
                                  more_env: []
                                  do_fork: T
                                )
                              ]
                            )
                          action: [
                            (command.Simple
                              words: [{<gettextln>} {(DQ <'bisect run cannot continue any more'>)}]
                              redirects: [
                                (redir
                                  op: <Id.Redir_GreatAnd '>&'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {<2>}
                                )
                              ]
                              more_env: []
                              do_fork: T
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Exit exit>
                              arg_word: {($ Id.VSub_DollarName res)}
                            )
                          ]
                          spids: [3471 3492]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<Id.Lit_LBracket '['>} {($ Id.VSub_DollarName res)} {<-ne>} {<0>} 
                                  {<Id.Lit_RBracket ']'>}
                                )
                              ]
                            )
                          action: [
                            (command.Simple
                              words: [
                                {<eval_gettextln>}
                                {
                                  (DQ <'bisect run failed:\n'> <'\'bisect_state '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                      ch: '$'
                                    ) <'state\' exited with error code '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') 
                                    <res>
                                  )
                                }
                              ]
                              redirects: [
                                (redir
                                  op: <Id.Redir_GreatAnd '>&'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {<2>}
                                )
                              ]
                              more_env: []
                              do_fork: T
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Exit exit>
                              arg_word: {($ Id.VSub_DollarName res)}
                            )
                          ]
                          spids: [3514 3527]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Simple
                                  words: [
                                    {<sane_grep>}
                                    {
                                      (DQ <'is the first '> ($ Id.VSub_DollarName TERM_BAD) <' commit'>)
                                    }
                                    {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_RUN'>)}
                                  ]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_Great '>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {<'/dev/null'>}
                                    )
                                  ]
                                  more_env: []
                                  do_fork: T
                                )
                              ]
                            )
                          action: [
                            (C {<gettextln>} {(DQ <'bisect run success'>)})
                            (command.Sentence
                              child: 
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Exit exit>
                                  arg_word: {<0>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          spids: [3554 3573]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                  ]
                )
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: bisect_log
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} {<-s>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_LOG'>)})
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<gettext>} {(DQ <'We are not bisecting.'>)})
                        right: <Id.Eof_RParen _>
                      )
                    )
                  }
                )
              ]
            )
            (C {<cat>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_LOG'>)})
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: get_terms
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<test>} {<-s>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_TERMS'>)})
                      ]
                    )
                  action: [
                    (BraceGroup
                      left: <Id.Lit_LBrace '{'>
                      children: [(C {<read>} {<TERM_BAD>}) (C {<read>} {<TERM_GOOD>})]
                      redirects: [
                        (redir
                          op: <Id.Redir_Less '<'>
                          loc: (redir_loc.Fd fd:0)
                          arg: {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_TERMS'>)}
                        )
                      ]
                      right: <Id.Lit_RBrace '}'>
                    )
                  ]
                  spids: [3648 3660]
                )
              ]
              else_action: []
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: write_terms
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'TERM_BAD='> name:TERM_BAD)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 1)}
                  spids: [3698]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'TERM_GOOD='> name:TERM_GOOD)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 2)}
                  spids: [3702]
                )
              ]
              redirects: []
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<test>} {(DQ ($ Id.VSub_DollarName TERM_BAD))} {<Id.Lit_Equals '='>} 
                          {(DQ ($ Id.VSub_DollarName TERM_GOOD))}
                        )
                      ]
                    )
                  action: [
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: (C {<gettext>} {(DQ <'please use two different terms'>)})
                            right: <Id.Eof_RParen _>
                          )
                        )
                      }
                    )
                  ]
                  spids: [3706 3721]
                )
              ]
              else_action: []
              redirects: []
            )
            (C {<check_term_format>} {(DQ ($ Id.VSub_DollarName TERM_BAD))} {<bad>})
            (C {<check_term_format>} {(DQ ($ Id.VSub_DollarName TERM_GOOD))} {<good>})
            (command.Simple
              words: [
                {<printf>}
                {(SQ <'%s\\n%s\\n'>)}
                {(DQ ($ Id.VSub_DollarName TERM_BAD))}
                {(DQ ($ Id.VSub_DollarName TERM_GOOD))}
              ]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_TERMS'>)}
                )
              ]
              more_env: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: check_term_format
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'term='> name:term)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 1)}
                  spids: [3789]
                )
              ]
              redirects: []
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<git>} {<check-ref-format>} {<'refs/bisect/'> (DQ ($ Id.VSub_DollarName term))})
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C {<eval_gettext>} 
                            {
                              (DQ <'\''> 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\$'>
                                  ch: '$'
                                ) <'term\' is not a valid term'>
                              )
                            }
                          )
                        right: <Id.Eof_RParen _>
                      )
                    )
                  }
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName term))}
              arms: [
                (case_arm
                  pat_list: [
                    {<help>}
                    {<start>}
                    {<terms>}
                    {<skip>}
                    {<next>}
                    {<reset>}
                    {<visualize>}
                    {<replay>}
                    {<log>}
                    {<run>}
                  ]
                  action: [
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<eval_gettext>} 
                                {
                                  (DQ <'can\'t use the builtin command \''> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                      ch: '$'
                                    ) <'term\' as a term'>
                                  )
                                }
                              )
                            right: <Id.Eof_RParen _>
                          )
                        )
                      }
                    )
                  ]
                  spids: [3829 3848 3866 -1]
                )
                (case_arm
                  pat_list: [{<bad>} {<new>}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<test>} {(DQ ($ Id.VSub_Number 2))} 
                                  {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<bad>}
                                )
                              ]
                            )
                          action: [
                            (C {<die>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<eval_gettext>} 
                                        {
                                          (DQ <'can\'t change the meaning of term \''> 
                                            (word_part.EscapedLiteral
                                              token: <Id.Lit_EscapedChar '\\$'>
                                              ch: '$'
                                            ) <'term\''>
                                          )
                                        }
                                      )
                                    right: <Id.Eof_RParen _>
                                  )
                                )
                              }
                            )
                          ]
                          spids: [3875 3889]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                  ]
                  spids: [3869 3872 3926 -1]
                )
                (case_arm
                  pat_list: [{<good>} {<old>}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<test>} {(DQ ($ Id.VSub_Number 2))} 
                                  {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<good>}
                                )
                              ]
                            )
                          action: [
                            (C {<die>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<eval_gettext>} 
                                        {
                                          (DQ <'can\'t change the meaning of term \''> 
                                            (word_part.EscapedLiteral
                                              token: <Id.Lit_EscapedChar '\\$'>
                                              ch: '$'
                                            ) <'term\''>
                                          )
                                        }
                                      )
                                    right: <Id.Eof_RParen _>
                                  )
                                )
                              }
                            )
                          ]
                          spids: [3935 3949]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                  ]
                  spids: [3929 3932 3970 -1]
                )
              ]
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: check_and_set_terms
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'cmd='> name:cmd)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number 1))}
                  spids: [3986]
                )
              ]
              redirects: []
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName cmd))}
              arms: [
                (case_arm
                  pat_list: [{<skip>} {<start>} {<terms>}]
                  action: []
                  spids: [4001 4006 4008 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp Id.Op_DAmp]
                                  children: [
                                    (C {<test>} {<-s>} 
                                      {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_TERMS'>)}
                                    )
                                    (C {<test>} {(DQ ($ Id.VSub_DollarName cmd))} 
                                      {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ ($ Id.VSub_DollarName TERM_BAD))}
                                    )
                                    (C {<test>} {(DQ ($ Id.VSub_DollarName cmd))} 
                                      {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ ($ Id.VSub_DollarName TERM_GOOD))}
                                    )
                                  ]
                                )
                              ]
                            )
                          action: [
                            (C {<die>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<eval_gettext>} 
                                        {
                                          (DQ <'Invalid command: you\'re currently in a '> 
                                            (word_part.EscapedLiteral
                                              token: <Id.Lit_EscapedChar '\\$'>
                                              ch: '$'
                                            ) <'TERM_BAD/'> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') <'TERM_GOOD bisect.'>
                                          )
                                        }
                                      )
                                    right: <Id.Eof_RParen _>
                                  )
                                )
                              }
                            )
                          ]
                          spids: [4015 4057]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName cmd))}
                      arms: [
                        (case_arm
                          pat_list: [{<bad>} {<good>}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Pipeline
                                          children: [
                                            (C {<test>} {<-s>} 
                                              {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_TERMS'>)}
                                            )
                                          ]
                                          negated: T
                                          stderr_indices: []
                                        )
                                      ]
                                    )
                                  action: [(C {<write_terms>} {<bad>} {<good>})]
                                  spids: [4095 4109]
                                )
                              ]
                              else_action: []
                              redirects: []
                            )
                          ]
                          spids: [4089 4092 4122 -1]
                        )
                        (case_arm
                          pat_list: [{<new>} {<old>}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Pipeline
                                          children: [
                                            (C {<test>} {<-s>} 
                                              {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_TERMS'>)}
                                            )
                                          ]
                                          negated: T
                                          stderr_indices: []
                                        )
                                      ]
                                    )
                                  action: [(C {<write_terms>} {<new>} {<old>})]
                                  spids: [4131 4145]
                                )
                              ]
                              else_action: []
                              redirects: []
                            )
                          ]
                          spids: [4125 4128 4158 -1]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [4011 4012 4163 -1]
                )
              ]
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: bisect_voc
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Case
              to_match: {(DQ ($ Id.VSub_Number 1))}
              arms: [
                (case_arm
                  pat_list: [{<bad>}]
                  action: [(C {<echo>} {(DQ <'bad|new'>)})]
                  spids: [4188 4189 4197 -1]
                )
                (case_arm
                  pat_list: [{<good>}]
                  action: [(C {<echo>} {(DQ <'good|old'>)})]
                  spids: [4200 4201 4209 -1]
                )
              ]
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: bisect_terms
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (C {<get_terms>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Pipeline
                          children: [
                            (C {<test>} {<-s>} {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/BISECT_TERMS'>)})
                          ]
                          negated: T
                          stderr_indices: []
                        )
                      ]
                    )
                  action: [
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: (C {<gettext>} {(DQ <'no terms defined'>)})
                            right: <Id.Eof_RParen _>
                          )
                        )
                      }
                    )
                  ]
                  spids: [4228 4242]
                )
              ]
              else_action: []
              redirects: []
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_Pound '#'))}
              arms: [
                (case_arm
                  pat_list: [{<0>}]
                  action: [
                    (C {<gettextln>} 
                      {
                        (DQ <'Your current terms are '> ($ Id.VSub_DollarName TERM_GOOD) 
                          <' for the old state\n'> <'and '> ($ Id.VSub_DollarName TERM_BAD) <' for the new state.'>
                        )
                      }
                    )
                  ]
                  spids: [4270 4271 4286 -1]
                )
                (case_arm
                  pat_list: [{<1>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'arg='> name:arg)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_Number 1)}
                          spids: [4293]
                        )
                      ]
                      redirects: []
                    )
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName arg))}
                      arms: [
                        (case_arm
                          pat_list: [{<--term-good>} {<--term-old>}]
                          action: [
                            (C {<printf>} {(SQ <'%s\\n'>)} {(DQ ($ Id.VSub_DollarName TERM_GOOD))})
                          ]
                          spids: [4306 4309 4323 -1]
                        )
                        (case_arm
                          pat_list: [{<--term-bad>} {<--term-new>}]
                          action: [
                            (C {<printf>} {(SQ <'%s\\n'>)} {(DQ ($ Id.VSub_DollarName TERM_BAD))})
                          ]
                          spids: [4326 4329 4343 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (C {<die>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<eval_gettext>} 
                                        {
                                          (DQ <'invalid argument '> 
                                            (word_part.EscapedLiteral
                                              token: <Id.Lit_EscapedChar '\\$'>
                                              ch: '$'
                                            ) <'arg for \'git bisect terms\'.\n'> 
                                            <
'Supported options are: --term-good|--term-old and --term-bad|--term-new.'
                                            >
                                          )
                                        }
                                      )
                                    right: <Id.Eof_RParen _>
                                  )
                                )
                              }
                            )
                          ]
                          spids: [4346 4347 4366 -1]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [4289 4290 4372 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [(C {<usage>})]
                  spids: [4375 4376 4381 -1]
                )
              ]
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.Case
      to_match: {(DQ ($ Id.VSub_Pound '#'))}
      arms: [
        (case_arm pat_list:[{<0>}] action:[(C {<usage>})] spids:[4397 4398 4403 -1])
        (case_arm
          pat_list: [{<Id.Lit_Star '*'>}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'cmd='> name:cmd)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number 1))}
                  spids: [4409]
                )
              ]
              redirects: []
            )
            (C {<get_terms>})
            (C {<shift>})
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName cmd))}
              arms: [
                (case_arm
                  pat_list: [{<help>}]
                  action: [(C {<git>} {<bisect>} {<-h>})]
                  spids: [4430 4431 4440 -1]
                )
                (case_arm
                  pat_list: [{<start>}]
                  action: [(C {<bisect_start>} {(DQ ($ Id.VSub_At '@'))})]
                  spids: [4443 4444 4453 -1]
                )
                (case_arm
                  pat_list: [
                    {<bad>}
                    {<good>}
                    {<new>}
                    {<old>}
                    {(DQ ($ Id.VSub_DollarName TERM_BAD))}
                    {(DQ ($ Id.VSub_DollarName TERM_GOOD))}
                  ]
                  action: [
                    (C {<bisect_state>} {(DQ ($ Id.VSub_DollarName cmd))} {(DQ ($ Id.VSub_At '@'))})
                  ]
                  spids: [4456 4471 4484 -1]
                )
                (case_arm
                  pat_list: [{<skip>}]
                  action: [(C {<bisect_skip>} {(DQ ($ Id.VSub_At '@'))})]
                  spids: [4487 4488 4497 -1]
                )
                (case_arm
                  pat_list: [{<next>}]
                  action: [(C {<bisect_next>} {(DQ ($ Id.VSub_At '@'))})]
                  spids: [4500 4501 4514 -1]
                )
                (case_arm
                  pat_list: [{<visualize>} {<view>}]
                  action: [(C {<bisect_visualize>} {(DQ ($ Id.VSub_At '@'))})]
                  spids: [4517 4520 4529 -1]
                )
                (case_arm
                  pat_list: [{<reset>}]
                  action: [(C {<bisect_reset>} {(DQ ($ Id.VSub_At '@'))})]
                  spids: [4532 4533 4542 -1]
                )
                (case_arm
                  pat_list: [{<replay>}]
                  action: [(C {<bisect_replay>} {(DQ ($ Id.VSub_At '@'))})]
                  spids: [4545 4546 4555 -1]
                )
                (case_arm
                  pat_list: [{<log>}]
                  action: [(C {<bisect_log>})]
                  spids: [4558 4559 4564 -1]
                )
                (case_arm
                  pat_list: [{<run>}]
                  action: [(C {<bisect_run>} {(DQ ($ Id.VSub_At '@'))})]
                  spids: [4567 4568 4577 -1]
                )
                (case_arm
                  pat_list: [{<terms>}]
                  action: [(C {<bisect_terms>} {(DQ ($ Id.VSub_At '@'))})]
                  spids: [4580 4581 4590 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [(C {<usage>})]
                  spids: [4593 4594 4599 -1]
                )
              ]
              redirects: []
            )
          ]
          spids: [4405 4406 -1 4604]
        )
      ]
      redirects: []
    )
  ]
)