(List
  (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('USAGE', {[SQ <LIT_CHARS "[help|start|bad|good|new|old|terms|skip|next|reset|visualize|replay|log|run]">]})])
  (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('LONG_USAGE', {[SQ <LIT_CHARS "git bisect help\n"> <LIT_CHARS "\tprint this long help message.\n"> <LIT_CHARS "git bisect start [--term-{old,good}=<term> --term-{new,bad}=<term>]\n"> <LIT_CHARS "\t\t [--no-checkout] [<bad> [<good>...]] [--] [<pathspec>...]\n"> <LIT_CHARS "\treset bisect state and start bisection.\n"> <LIT_CHARS "git bisect (bad|new) [<rev>]\n"> <LIT_CHARS "\tmark <rev> a known-bad revision/\n"> <LIT_CHARS "\t\ta revision after change in a given property.\n"> <LIT_CHARS "git bisect (good|old) [<rev>...]\n"> <LIT_CHARS "\tmark <rev>... known-good revisions/\n"> <LIT_CHARS "\t\trevisions before change in a given property.\n"> <LIT_CHARS "git bisect terms [--term-good | --term-bad]\n"> <LIT_CHARS "\tshow the terms used for old and new commits (default: bad, good)\n"> <LIT_CHARS "git bisect skip [(<rev>|<range>)...]\n"> <LIT_CHARS "\tmark <rev>... untestable revisions.\n"> <LIT_CHARS "git bisect next\n"> <LIT_CHARS "\tfind next bisection to test and check it out.\n"> <LIT_CHARS "git bisect reset [<commit>]\n"> <LIT_CHARS "\tfinish bisection search and go back to commit.\n"> <LIT_CHARS "git bisect visualize\n"> <LIT_CHARS "\tshow bisect status in gitk.\n"> <LIT_CHARS "git bisect replay <logfile>\n"> <LIT_CHARS "\treplay bisection log.\n"> <LIT_CHARS "git bisect log\n"> <LIT_CHARS "\tshow bisect log.\n"> <LIT_CHARS "git bisect run <cmd>...\n"> <LIT_CHARS "\tuse <cmd>... to automatically bisect.\n"> <LIT_CHARS "\n"> <LIT_CHARS "Please use \"git help bisect\" to get the full man page.">]})])
  (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('OPTIONS_SPEC', {[SQ ]})])
  (Com {[LIT_CHARS .]} {[LIT_CHARS git-sh-setup]})
  (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('_x40', {[SQ <LIT_CHARS "[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]">]})])
  (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('_x40', {[DQ [VarSub _x40][VarSub _x40][VarSub _x40][VarSub _x40][VarSub _x40][VarSub _x40][VarSub _x40][VarSub _x40]]})])
  (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('TERM_BAD', {[LIT_CHARS bad]})])
  (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('TERM_GOOD', {[LIT_CHARS good]})])
  (FunctionDef bisect_head []
    (If
      (Com {[LIT_CHARS test]} {[LIT_CHARS -f]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_HEAD]]})
      (Com {[LIT_CHARS echo]} {[LIT_CHARS BISECT_HEAD]})
      (ElseTrue)
      (Com {[LIT_CHARS echo]} {[LIT_CHARS HEAD]})
    )
  )
  (FunctionDef bisect_autostart []
    (AndOr OP_OR_IF
      (Com {[LIT_CHARS test]} {[LIT_CHARS -s]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_START]]})
      (List
        (Com {[LIT_CHARS gettextln]} {[DQ [LIT_CHARS "You need to start by "][\ LIT_ESCAPED_CHAR "\\\""][LIT_CHARS "git bisect start"][\ LIT_ESCAPED_CHAR "\\\""]]}
          <
          (DescriptorRedirectNode target={[LIT_CHARS 2]} <REDIR_GREATAND ">&"> 1),
          >
        )
        (If
          (Com {[LIT_CHARS test]} {[LIT_CHARS -t]} {[LIT_CHARS 0]})
          (List
            (Com {[LIT_CHARS gettext]} {[DQ [LIT_CHARS "Do you want me to do it for you [Y/n]? "]]}
              <
              (DescriptorRedirectNode target={[LIT_CHARS 2]} <REDIR_GREATAND ">&"> 1),
              >
            )
            (Com {[LIT_CHARS read]} {[LIT_CHARS yesno]})
            (Case to_match={[DQ [VarSub yesno]]}, pat_word_list=[[{[LIT_OTHER "["] [LIT_CHARS Nn] [LIT_OTHER "]"] [LIT_OTHER "*"]}]]
              (Com {[LIT_CHARS exit]})
            )
            (Com {[LIT_CHARS bisect_start]})
          )
          (ElseTrue)
          (Com {[LIT_CHARS exit]} {[LIT_CHARS 1]})
        )
      )
    )
  )
  (FunctionDef bisect_start []
    (List
      (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('has_double_dash', {[LIT_CHARS 0]})])
      (For arg do_arg_iter)
        (Case to_match={[DQ [VarSub arg]]}, pat_word_list=[[{[LIT_CHARS --]}]]
          (List
            (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('has_double_dash', {[LIT_CHARS 1]})])
            (Com {[LIT_CHARS break]})
          )
        )
      )
      (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('orig_args', {[ComSub (Com {[LIT_CHARS git]} {[LIT_CHARS rev-parse]} {[LIT_CHARS --sq-quote]} {[DQ [VarSub @]]})]})])
      (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('bad_seen', {[LIT_CHARS 0]})])
      (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('eval', {[SQ ]})])
      (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('must_write_terms', {[LIT_CHARS 0]})])
      (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('revs', {[SQ ]})])
      (If
        (Com {[LIT_CHARS test]} {[DQ [LIT_CHARS z][ComSub (Com {[LIT_CHARS git]} {[LIT_CHARS rev-parse]} {[LIT_CHARS --is-bare-repository]})]]} {[LIT_OTHER "!"] [LIT_OTHER "="]} {[LIT_CHARS zfalse]})
        (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('mode', {[LIT_CHARS --no-checkout]})])
        (ElseTrue)
        (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('mode', {[SQ ]})])
      )
      (While
        (Com {[LIT_OTHER "["]} {[VarSub #]} {[LIT_CHARS -gt]} {[LIT_CHARS 0]} {[LIT_OTHER "]"]})
        (List
          (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('arg', {[DQ [VarSub 1]]})])
          (Case to_match={[DQ [VarSub arg]]}, pat_word_list=[[{[LIT_CHARS --]}], [{[LIT_CHARS --no-checkout]}], [{[LIT_CHARS --term-good]}, {[LIT_CHARS --term-old]}], [{[LIT_CHARS --term-good] [LIT_OTHER "="] [LIT_OTHER "*"]}, {[LIT_CHARS --term-old] [LIT_OTHER "="] [LIT_OTHER "*"]}], [{[LIT_CHARS --term-bad]}, {[LIT_CHARS --term-new]}], [{[LIT_CHARS --term-bad] [LIT_OTHER "="] [LIT_OTHER "*"]}, {[LIT_CHARS --term-new] [LIT_OTHER "="] [LIT_OTHER "*"]}], [{[LIT_CHARS --] [LIT_OTHER "*"]}], [{[LIT_OTHER "*"]}]]
            (List
              (Com {[LIT_CHARS shift]})
              (Com {[LIT_CHARS break]})
            )
            (List
              (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('mode', {[LIT_CHARS --no-checkout]})])
              (Com {[LIT_CHARS shift]})
            )
            (List
              (Com {[LIT_CHARS shift]})
              (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('must_write_terms', {[LIT_CHARS 1]})])
              (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('TERM_GOOD', {[VarSub 1]})])
              (Com {[LIT_CHARS shift]})
            )
            (List
              (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('must_write_terms', {[LIT_CHARS 1]})])
              (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('TERM_GOOD', {[VarSub 1 transform_ops=[VS_UNARY_POUND {[LIT_CHARS "*="]}]]})])
              (Com {[LIT_CHARS shift]})
            )
            (List
              (Com {[LIT_CHARS shift]})
              (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('must_write_terms', {[LIT_CHARS 1]})])
              (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('TERM_BAD', {[VarSub 1]})])
              (Com {[LIT_CHARS shift]})
            )
            (List
              (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('must_write_terms', {[LIT_CHARS 1]})])
              (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('TERM_BAD', {[VarSub 1 transform_ops=[VS_UNARY_POUND {[LIT_CHARS "*="]}]]})])
              (Com {[LIT_CHARS shift]})
            )
            (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS eval_gettext]} {[DQ [LIT_CHARS "unrecognised option: '"][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS "arg'"]]})]]})
            (List
              (AndOr OP_OR_IF
                (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('rev', {[ComSub (Com {[LIT_CHARS git]} {[LIT_CHARS rev-parse]} {[LIT_CHARS -q]} {[LIT_CHARS --verify]} {[DQ [VarSub arg][LIT_CHARS "^{commit}"]]})]})])
                (List
                  (AndOr OP_AND_IF
                    (Com {[LIT_CHARS test]} {[VarSub has_double_dash]} {[LIT_CHARS -eq]} {[LIT_CHARS 1]})
                    (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS eval_gettext]} {[DQ [LIT_CHARS "'"][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS "arg' does not appear to be a valid revision"]]})]]})
                  )
                  (Com {[LIT_CHARS break]})
                )
              )
              (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('revs', {[DQ [VarSub revs][LIT_CHARS " "][VarSub rev]]})])
              (Com {[LIT_CHARS shift]})
            )
          )
        )
      )
      (For rev [{[VarSub revs]}])
        (List
          (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('must_write_terms', {[LIT_CHARS 1]})])
          (Case to_match={[VarSub bad_seen]}, pat_word_list=[[{[LIT_CHARS 0]}], [{[LIT_OTHER "*"]}]]
            (List
              (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('state', {[VarSub TERM_BAD]})])
              (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('bad_seen', {[LIT_CHARS 1]})])
            )
            (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('state', {[VarSub TERM_GOOD]})])
          )
          (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('eval', {[DQ [VarSub eval][LIT_CHARS " bisect_write '"][VarSub state][LIT_CHARS "' '"][VarSub rev][LIT_CHARS "' 'nolog' &&"]]})])
        )
      )
      (AndOr OP_OR_IF
        (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('head', {[ComSub (Com more_env=[('GIT_DIR', {[DQ [VarSub GIT_DIR]]})] {[LIT_CHARS git]} {[LIT_CHARS symbolic-ref]} {[LIT_CHARS -q]} {[LIT_CHARS HEAD]})]})])
        (AndOr OP_OR_IF
          (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('head', {[ComSub (Com more_env=[('GIT_DIR', {[DQ [VarSub GIT_DIR]]})] {[LIT_CHARS git]} {[LIT_CHARS rev-parse]} {[LIT_CHARS --verify]} {[LIT_CHARS HEAD]})]})])
          (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS gettext]} {[DQ [LIT_CHARS "Bad HEAD - I need a HEAD"]]})]]})
        )
      )
      (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('start_head', {[SQ ]})])
      (If
        (Com {[LIT_CHARS test]} {[LIT_CHARS -s]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_START]]})
        (List
          (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('start_head', {[ComSub (Com {[LIT_CHARS cat]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_START]]})]})])
          (If
            (Com {[LIT_CHARS test]} {[DQ [LIT_CHARS z][VarSub mode]]} {[LIT_OTHER "!"] [LIT_OTHER "="]} {[DQ [LIT_CHARS z--no-checkout]]})
            (AndOr OP_OR_IF
              (Com {[LIT_CHARS git]} {[LIT_CHARS checkout]} {[DQ [VarSub start_head]]} {[LIT_CHARS --]})
              (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS eval_gettext]} {[DQ [LIT_CHARS "Checking out '"][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS "start_head' failed. Try 'git bisect reset <valid-branch>'."]]})]]})
            )
          )
        )
        (ElseTrue)
        (Case to_match={[DQ [VarSub head]]}, pat_word_list=[[{[LIT_CHARS refs/heads/] [LIT_OTHER "*"]}, {[VarSub _x40]}], [{[LIT_OTHER "*"]}]]
          (List
            (AndOr OP_AND_IF
              (Com {[LIT_OTHER "["]} {[LIT_CHARS -s]} {[DQ [VarSub GIT_DIR][LIT_CHARS /head-name]]} {[LIT_OTHER "]"]})
              (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS gettext]} {[DQ [LIT_CHARS "won't bisect on cg-seek'ed tree"]]})]]})
            )
            (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('start_head', {[DQ [VarSub head transform_ops=[VS_UNARY_POUND {[LIT_CHARS refs] [LIT_SLASH /] [LIT_CHARS heads] [LIT_SLASH /]}]]]})])
          )
          (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS gettext]} {[DQ [LIT_CHARS "Bad HEAD - strange symbolic ref"]]})]]})
        )
      )
      (AndOr OP_OR_IF
        (Com {[LIT_CHARS bisect_clean_state]})
        (Com {[LIT_CHARS exit]})
      )
      (Com {[LIT_CHARS trap]} {[SQ <LIT_CHARS bisect_clean_state>]} {[LIT_CHARS 0]})
      (Com {[LIT_CHARS trap]} {[SQ <LIT_CHARS "exit 255">]} {[LIT_CHARS 1]} {[LIT_CHARS 2]} {[LIT_CHARS 3]} {[LIT_CHARS 15]})
      (AndOr OP_AND_IF
        (Com {[LIT_CHARS echo]} {[DQ [VarSub start_head]]}
          <
          (FilenameRedirectNode filename={[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_START]]} <REDIR_GREAT ">"> 1),
          >
        )
        (AndOr OP_AND_IF
          (AndOr OP_OR_IF
            (Com {[LIT_CHARS test]} {[DQ [LIT_CHARS z][VarSub mode]]} {[LIT_OTHER "!"] [LIT_OTHER "="]} {[DQ [LIT_CHARS z--no-checkout]]})
            (Com {[LIT_CHARS git]} {[LIT_CHARS update-ref]} {[LIT_CHARS --no-deref]} {[LIT_CHARS BISECT_HEAD]} {[DQ [VarSub start_head]]})
          )
          (AndOr OP_AND_IF
            (Com {[LIT_CHARS git]} {[LIT_CHARS rev-parse]} {[LIT_CHARS --sq-quote]} {[DQ [VarSub @]]}
              <
              (FilenameRedirectNode filename={[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_NAMES]]} <REDIR_GREAT ">"> 1),
              >
            )
            (AndOr OP_AND_IF
              (Com {[LIT_CHARS eval]} {[DQ [VarSub eval][LIT_CHARS " true"]]})
              (AndOr OP_AND_IF
                (If
                  (Com {[LIT_CHARS test]} {[VarSub must_write_terms]} {[LIT_CHARS -eq]} {[LIT_CHARS 1]})
                  (Com {[LIT_CHARS write_terms]} {[DQ [VarSub TERM_BAD]]} {[DQ [VarSub TERM_GOOD]]})
                )
                (AndOr OP_OR_IF
                  (Com {[LIT_CHARS echo]} {[DQ [LIT_CHARS "git bisect start"][VarSub orig_args]]}
                    <
                    (FilenameRedirectNode filename={[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_LOG]]} <REDIR_DGREAT ">>"> 1),
                    >
                  )
                  (Com {[LIT_CHARS exit]})
                )
              )
            )
          )
        )
      )
      (Com {[LIT_CHARS bisect_auto_next]})
      (Com {[LIT_CHARS trap]} {[SQ <LIT_CHARS ->]} {[LIT_CHARS 0]})
    )
  )
  (FunctionDef bisect_write []
    (List
      (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('state', {[DQ [VarSub 1]]})])
      (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('rev', {[DQ [VarSub 2]]})])
      (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('nolog', {[DQ [VarSub 3]]})])
      (Case to_match={[DQ [VarSub state]]}, pat_word_list=[[{[DQ [VarSub TERM_BAD]]}], [{[DQ [VarSub TERM_GOOD]]}, {[LIT_CHARS skip]}], [{[LIT_OTHER "*"]}]]
        (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('tag', {[DQ [VarSub state]]})])
        (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('tag', {[DQ [VarSub state]] [LIT_CHARS -] [DQ [VarSub rev]]})])
        (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS eval_gettext]} {[DQ [LIT_CHARS "Bad bisect_write argument: "][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS state]]})]]})
      )
      (AndOr OP_OR_IF
        (Com {[LIT_CHARS git]} {[LIT_CHARS update-ref]} {[DQ [LIT_CHARS refs/bisect/][VarSub tag]]} {[DQ [VarSub rev]]})
        (Com {[LIT_CHARS exit]})
      )
      (Com {[LIT_CHARS echo]} {[DQ [LIT_CHARS "# "][VarSub state][LIT_CHARS ": "][ComSub (Com {[LIT_CHARS git]} {[LIT_CHARS show-branch]} {[VarSub rev]})]]}
        <
        (FilenameRedirectNode filename={[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_LOG]]} <REDIR_DGREAT ">>"> 1),
        >
      )
      (AndOr OP_OR_IF
        (Com {[LIT_CHARS test]} {[LIT_CHARS -n]} {[DQ [VarSub nolog]]})
        (Com {[LIT_CHARS echo]} {[DQ [LIT_CHARS "git bisect "][VarSub state][LIT_CHARS " "][VarSub rev]]}
          <
          (FilenameRedirectNode filename={[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_LOG]]} <REDIR_DGREAT ">>"> 1),
          >
        )
      )
    )
  )
  (FunctionDef is_expected_rev []
    (AndOr OP_AND_IF
      (Com {[LIT_CHARS test]} {[LIT_CHARS -f]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_EXPECTED_REV]]})
      (Com {[LIT_CHARS test]} {[DQ [VarSub 1]]} {[LIT_OTHER "="]} {[ComSub (Com {[LIT_CHARS cat]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_EXPECTED_REV]]})]})
    )
  )
  (FunctionDef check_expected_revs []
    (For _rev [{[DQ [VarSub @]]}])
      (If
        (Pipeline!
          (Com {[LIT_CHARS is_expected_rev]} {[DQ [VarSub _rev]]})
        )
        (List
          (Com {[LIT_CHARS rm]} {[LIT_CHARS -f]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_ANCESTORS_OK]]})
          (Com {[LIT_CHARS rm]} {[LIT_CHARS -f]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_EXPECTED_REV]]})
          (Com {[LIT_CHARS return]})
        )
      )
    )
  )
  (FunctionDef bisect_skip []
    (List
      (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('all', {[SQ ]})])
      (For arg [{[DQ [VarSub @]]}])
        (List
          (Case to_match={[DQ [VarSub arg]]}, pat_word_list=[[{[LIT_OTHER "*"] [LIT_CHARS ..] [LIT_OTHER "*"]}], [{[LIT_OTHER "*"]}]]
            (AndOr OP_OR_IF
              (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('revs', {[ComSub (Com {[LIT_CHARS git]} {[LIT_CHARS rev-list]} {[DQ [VarSub arg]]})]})])
              (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS eval_gettext]} {[DQ [LIT_CHARS "Bad rev input: "][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS arg]]})]]})
            )
            (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('revs', {[ComSub (Com {[LIT_CHARS git]} {[LIT_CHARS rev-parse]} {[LIT_CHARS --sq-quote]} {[DQ [VarSub arg]]})]})])
          )
          (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('all', {[DQ [VarSub all][LIT_CHARS " "][VarSub revs]]})])
        )
      )
      (Com {[LIT_CHARS eval]} {[LIT_CHARS bisect_state]} {[SQ <LIT_CHARS skip>]} {[VarSub all]})
    )
  )
  (FunctionDef bisect_state []
    (List
      (Com {[LIT_CHARS bisect_autostart]})
      (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('state', {[VarSub 1]})])
      (Com {[LIT_CHARS check_and_set_terms]} {[VarSub state]})
      (Case to_match={[DQ [VarSub #][LIT_CHARS ","][VarSub state]]}, pat_word_list=[[{[LIT_CHARS 0] [LIT_COMMA ","] [LIT_OTHER "*"]}], [{[LIT_CHARS 1] [LIT_COMMA ","] [DQ [VarSub TERM_BAD]]}, {[LIT_CHARS 1] [LIT_COMMA ","] [DQ [VarSub TERM_GOOD]]}, {[LIT_CHARS 1] [LIT_COMMA ","] [LIT_CHARS skip]}], [{[LIT_CHARS 2] [LIT_COMMA ","] [DQ [VarSub TERM_BAD]]}, {[LIT_OTHER "*"] [LIT_COMMA ","] [DQ [VarSub TERM_GOOD]]}, {[LIT_OTHER "*"] [LIT_COMMA ","] [LIT_CHARS skip]}], [{[LIT_OTHER "*"] [LIT_COMMA ","] [DQ [VarSub TERM_BAD]]}], [{[LIT_OTHER "*"]}]]
        (Com {[LIT_CHARS die]} {[DQ [LIT_CHARS "Please call 'bisect_state' with at least one argument."]]})
        (List
          (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('bisected_head', {[ComSub (Com {[LIT_CHARS bisect_head]})]})])
          (AndOr OP_OR_IF
            (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('rev', {[ComSub (Com {[LIT_CHARS git]} {[LIT_CHARS rev-parse]} {[LIT_CHARS --verify]} {[DQ [VarSub bisected_head]]})]})])
            (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS eval_gettext]} {[DQ [LIT_CHARS "Bad rev input: "][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS bisected_head]]})]]})
          )
          (Com {[LIT_CHARS bisect_write]} {[DQ [VarSub state]]} {[DQ [VarSub rev]]})
          (Com {[LIT_CHARS check_expected_revs]} {[DQ [VarSub rev]]})
        )
        (List
          (Com {[LIT_CHARS shift]})
          (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('hash_list', {[SQ ]})])
          (For rev [{[DQ [VarSub @]]}])
            (List
              (AndOr OP_OR_IF
                (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('sha', {[ComSub (Com {[LIT_CHARS git]} {[LIT_CHARS rev-parse]} {[LIT_CHARS --verify]} {[DQ [VarSub rev][LIT_CHARS "^{commit}"]]})]})])
                (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS eval_gettext]} {[DQ [LIT_CHARS "Bad rev input: "][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS rev]]})]]})
              )
              (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('hash_list', {[DQ [VarSub hash_list][LIT_CHARS " "][VarSub sha]]})])
            )
          )
          (For rev [{[VarSub hash_list]}])
            (Com {[LIT_CHARS bisect_write]} {[DQ [VarSub state]]} {[DQ [VarSub rev]]})
          )
          (Com {[LIT_CHARS check_expected_revs]} {[VarSub hash_list]})
        )
        (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS eval_gettext]} {[DQ [LIT_CHARS "'git bisect "][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS "TERM_BAD' can take only one argument."]]})]]})
        (Com {[LIT_CHARS usage]})
      )
      (Com {[LIT_CHARS bisect_auto_next]})
    )
  )
  (FunctionDef bisect_next_check []
    (List
      (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('missing_good', {[SQ ]}), ('missing_bad', {[SQ ]})])
      (AndOr OP_OR_IF
        (Com {[LIT_CHARS git]} {[LIT_CHARS show-ref]} {[LIT_CHARS -q]} {[LIT_CHARS --verify]} {[LIT_CHARS refs/bisect/] [VarSub TERM_BAD]})
        (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('missing_bad', {[LIT_CHARS t]})])
      )
      (AndOr OP_OR_IF
        (Com {[LIT_CHARS test]} {[LIT_CHARS -n]} {[DQ [ComSub (Com {[LIT_CHARS git]} {[LIT_CHARS for-each-ref]} {[DQ [LIT_CHARS refs/bisect/][VarSub TERM_GOOD][LIT_CHARS "-*"]]})]]})
        (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('missing_good', {[LIT_CHARS t]})])
      )
      (Case to_match={[DQ [VarSub missing_good][LIT_CHARS ","][VarSub missing_bad][LIT_CHARS ","][VarSub 1]]}, pat_word_list=[[{[LIT_COMMA ","] [LIT_COMMA ","] [LIT_OTHER "*"]}], [{[LIT_OTHER "*"] [LIT_COMMA ","]}], [{[LIT_CHARS t] [LIT_COMMA ","] [LIT_COMMA ","] [DQ [VarSub TERM_GOOD]]}], [{[LIT_OTHER "*"]}]]
        (Com {[LIT_OTHER ":"]} {[LIT_CHARS have]} {[LIT_CHARS both]} {[VarSub TERM_GOOD]} {[LIT_CHARS and]} {[VarSub TERM_BAD]} {[LIT_CHARS -]} {[LIT_CHARS ok]})
        (Com {[LIT_CHARS false]})
        (List
          (Com {[LIT_CHARS eval_gettextln]} {[DQ [LIT_CHARS "Warning: bisecting only with a "][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS "TERM_BAD commit."]]}
            <
            (DescriptorRedirectNode target={[LIT_CHARS 2]} <REDIR_GREATAND ">&"> 1),
            >
          )
          (If
            (Com {[LIT_CHARS test]} {[LIT_CHARS -t]} {[LIT_CHARS 0]})
            (List
              (Com {[LIT_CHARS gettext]} {[DQ [LIT_CHARS "Are you sure [Y/n]? "]]}
                <
                (DescriptorRedirectNode target={[LIT_CHARS 2]} <REDIR_GREATAND ">&"> 1),
                >
              )
              (Com {[LIT_CHARS read]} {[LIT_CHARS yesno]})
              (Case to_match={[DQ [VarSub yesno]]}, pat_word_list=[[{[LIT_OTHER "["] [LIT_CHARS Nn] [LIT_OTHER "]"] [LIT_OTHER "*"]}]]
                (Com {[LIT_CHARS exit]} {[LIT_CHARS 1]})
              )
            )
          )
          (Com {[LIT_OTHER ":"]} {[LIT_CHARS bisect]} {[LIT_CHARS without]} {[VarSub TERM_GOOD] [LIT_CHARS ...]})
        )
        (List
          (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('bad_syn', {[ComSub (Com {[LIT_CHARS bisect_voc]} {[LIT_CHARS bad]})]})])
          (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('good_syn', {[ComSub (Com {[LIT_CHARS bisect_voc]} {[LIT_CHARS good]})]})])
          (If
            (Com {[LIT_CHARS test]} {[LIT_CHARS -s]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_START]]})
            (Com {[LIT_CHARS eval_gettextln]} {[DQ [LIT_CHARS "You need to give me at least one "][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS "bad_syn and one "][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS "good_syn revision.\n"][LIT_CHARS "(You can use "][\ LIT_ESCAPED_CHAR "\\\""][LIT_CHARS "git bisect "][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS bad_syn][\ LIT_ESCAPED_CHAR "\\\""][LIT_CHARS " and "][\ LIT_ESCAPED_CHAR "\\\""][LIT_CHARS "git bisect "][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS good_syn][\ LIT_ESCAPED_CHAR "\\\""][LIT_CHARS " for that.)"]]}
              <
              (DescriptorRedirectNode target={[LIT_CHARS 2]} <REDIR_GREATAND ">&"> 1),
              >
            )
            (ElseTrue)
            (Com {[LIT_CHARS eval_gettextln]} {[DQ [LIT_CHARS "You need to start by "][\ LIT_ESCAPED_CHAR "\\\""][LIT_CHARS "git bisect start"][\ LIT_ESCAPED_CHAR "\\\""][LIT_CHARS ".\n"][LIT_CHARS "You then need to give me at least one "][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS "good_syn and one "][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS "bad_syn revision.\n"][LIT_CHARS "(You can use "][\ LIT_ESCAPED_CHAR "\\\""][LIT_CHARS "git bisect "][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS bad_syn][\ LIT_ESCAPED_CHAR "\\\""][LIT_CHARS " and "][\ LIT_ESCAPED_CHAR "\\\""][LIT_CHARS "git bisect "][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS good_syn][\ LIT_ESCAPED_CHAR "\\\""][LIT_CHARS " for that.)"]]}
              <
              (DescriptorRedirectNode target={[LIT_CHARS 2]} <REDIR_GREATAND ">&"> 1),
              >
            )
          )
          (Com {[LIT_CHARS exit]} {[LIT_CHARS 1]})
        )
      )
    )
  )
  (FunctionDef bisect_auto_next []
    (AndOr OP_AND_IF
      (Com {[LIT_CHARS bisect_next_check]})
      (AndOr OP_OR_IF
        (Com {[LIT_CHARS bisect_next]})
        (Com {[LIT_OTHER ":"]})
      )
    )
  )
  (FunctionDef bisect_next []
    (List
      (Case to_match={[DQ [VarSub #]]}, pat_word_list=[[{[LIT_CHARS 0]}], [{[LIT_OTHER "*"]}]]
        (ElseTrue)
        (Com {[LIT_CHARS usage]})
      )
      (Com {[LIT_CHARS bisect_autostart]})
      (Com {[LIT_CHARS bisect_next_check]} {[VarSub TERM_GOOD]})
      (Com {[LIT_CHARS git]} {[LIT_CHARS bisect--helper]} {[LIT_CHARS --next-all]} {[ComSub (AndOr OP_AND_IF (Com {[LIT_CHARS test]} {[LIT_CHARS -f]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_HEAD]]}) (Com {[LIT_CHARS echo]} {[LIT_CHARS --no-checkout]}) )]})
      (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('res', {[VarSub ?]})])
      (If
        (Com {[LIT_CHARS test]} {[VarSub res]} {[LIT_CHARS -eq]} {[LIT_CHARS 10]})
        (List
          (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('bad_rev', {[ComSub (Com {[LIT_CHARS git]} {[LIT_CHARS show-ref]} {[LIT_CHARS --hash]} {[LIT_CHARS --verify]} {[LIT_CHARS refs/bisect/] [VarSub TERM_BAD]})]})])
          (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('bad_commit', {[ComSub (Com {[LIT_CHARS git]} {[LIT_CHARS show-branch]} {[VarSub bad_rev]})]})])
          (Com {[LIT_CHARS echo]} {[DQ [LIT_CHARS "# first "][VarSub TERM_BAD][LIT_CHARS " commit: "][VarSub bad_commit]]}
            <
            (FilenameRedirectNode filename={[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_LOG]]} <REDIR_DGREAT ">>"> 1),
            >
          )
          (Com {[LIT_CHARS exit]} {[LIT_CHARS 0]})
        )
        (Com {[LIT_CHARS test]} {[VarSub res]} {[LIT_CHARS -eq]} {[LIT_CHARS 2]})
        (List
          (Com {[LIT_CHARS echo]} {[DQ [LIT_CHARS "# only skipped commits left to test"]]}
            <
            (FilenameRedirectNode filename={[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_LOG]]} <REDIR_DGREAT ">>"> 1),
            >
          )
          (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('good_revs', {[ComSub (Com {[LIT_CHARS git]} {[LIT_CHARS for-each-ref]} {[LIT_CHARS --format] [LIT_OTHER "="] [DQ [LIT_CHARS "%(objectname)"]]} {[DQ [LIT_CHARS refs/bisect/][VarSub TERM_GOOD][LIT_CHARS "-*"]]})]})])
          (For skipped [{[ComSub (Com {[LIT_CHARS git]} {[LIT_CHARS rev-list]} {[LIT_CHARS refs/bisect/] [VarSub TERM_BAD]} {[LIT_CHARS --not]} {[VarSub good_revs]})]}])
            (List
              (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('skipped_commit', {[ComSub (Com {[LIT_CHARS git]} {[LIT_CHARS show-branch]} {[VarSub skipped]})]})])
              (Com {[LIT_CHARS echo]} {[DQ [LIT_CHARS "# possible first "][VarSub TERM_BAD][LIT_CHARS " commit: "][VarSub skipped_commit]]}
                <
                (FilenameRedirectNode filename={[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_LOG]]} <REDIR_DGREAT ">>"> 1),
                >
              )
            )
          )
          (Com {[LIT_CHARS exit]} {[VarSub res]})
        )
      )
      (AndOr OP_AND_IF
        (Com {[LIT_CHARS test]} {[VarSub res]} {[LIT_CHARS -ne]} {[LIT_CHARS 0]})
        (Com {[LIT_CHARS exit]} {[VarSub res]})
      )
      (Com {[LIT_CHARS return]} {[LIT_CHARS 0]})
    )
  )
  (FunctionDef bisect_visualize []
    (List
      (Com {[LIT_CHARS bisect_next_check]} {[LIT_CHARS fail]})
      (If
        (Com {[LIT_CHARS test]} {[VarSub #]} {[LIT_OTHER "="]} {[LIT_CHARS 0]})
        (If
          (AndOr OP_AND_IF
            (Com {[LIT_CHARS test]} {[LIT_CHARS -n]} {[DQ [VarSub DISPLAY test_op=VS_TEST_PLUS {[LIT_CHARS set]}][VarSub SESSIONNAME test_op=VS_TEST_PLUS {[LIT_CHARS set]}][VarSub MSYSTEM test_op=VS_TEST_PLUS {[LIT_CHARS set]}][VarSub SECURITYSESSIONID test_op=VS_TEST_PLUS {[LIT_CHARS set]}]]})
            (Com {[LIT_CHARS type]} {[LIT_CHARS gitk]}
              <
              (FilenameRedirectNode filename={[LIT_CHARS /dev/null]} <REDIR_GREAT ">"> 1),
              (DescriptorRedirectNode target={[LIT_CHARS 1]} <REDIR_GREATAND "2>&"> 2),
              >
            )
          )
          (Com {[LIT_CHARS set]} {[LIT_CHARS gitk]})
          (ElseTrue)
          (Com {[LIT_CHARS set]} {[LIT_CHARS git]} {[LIT_CHARS log]})
        )
        (ElseTrue)
        (Case to_match={[DQ [VarSub 1]]}, pat_word_list=[[{[LIT_CHARS git] [LIT_OTHER "*"]}, {[LIT_CHARS tig]}], [{[LIT_CHARS -] [LIT_OTHER "*"]}], [{[LIT_OTHER "*"]}]]
          (ElseTrue)
          (Com {[LIT_CHARS set]} {[LIT_CHARS git]} {[LIT_CHARS log]} {[DQ [VarSub @]]})
          (Com {[LIT_CHARS set]} {[LIT_CHARS git]} {[DQ [VarSub @]]})
        )
      )
      (Com {[LIT_CHARS eval]} {[SQ <LIT_CHARS "\"$@\"">]} {[LIT_CHARS --bisect]} {[LIT_CHARS --]} {[ComSub (Com {[LIT_CHARS cat]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_NAMES]]})]})
    )
  )
  (FunctionDef bisect_reset []
    (List
      (AndOr OP_OR_IF
        (Com {[LIT_CHARS test]} {[LIT_CHARS -s]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_START]]})
        (List
          (Com {[LIT_CHARS gettextln]} {[DQ [LIT_CHARS "We are not bisecting."]]})
          (Com {[LIT_CHARS return]})
        )
      )
      (Case to_match={[DQ [VarSub #]]}, pat_word_list=[[{[LIT_CHARS 0]}], [{[LIT_CHARS 1]}], [{[LIT_OTHER "*"]}]]
        (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('branch', {[ComSub (Com {[LIT_CHARS cat]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_START]]})]})])
        (List
          (AndOr OP_OR_IF
            (Com {[LIT_CHARS git]} {[LIT_CHARS rev-parse]} {[LIT_CHARS --quiet]} {[LIT_CHARS --verify]} {[DQ [VarSub 1][LIT_CHARS "^{commit}"]]}
              <
              (FilenameRedirectNode filename={[LIT_CHARS /dev/null]} <REDIR_GREAT ">"> 1),
              >
            )
            (List
              (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('invalid', {[DQ [VarSub 1]]})])
              (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS eval_gettext]} {[DQ [LIT_CHARS "'"][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS "invalid' is not a valid commit"]]})]]})
            )
          )
          (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('branch', {[DQ [VarSub 1]]})])
        )
        (Com {[LIT_CHARS usage]})
      )
      (If
        (AndOr OP_AND_IF
          (Pipeline!
            (Com {[LIT_CHARS test]} {[LIT_CHARS -f]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_HEAD]]})
          )
          (Pipeline!
            (Com {[LIT_CHARS git]} {[LIT_CHARS checkout]} {[DQ [VarSub branch]]} {[LIT_CHARS --]})
          )
        )
        (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS eval_gettext]} {[DQ [LIT_CHARS "Could not check out original HEAD '"][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS "branch'.\n"][LIT_CHARS "Try 'git bisect reset <commit>'."]]})]]})
      )
      (Com {[LIT_CHARS bisect_clean_state]})
    )
  )
  (FunctionDef bisect_clean_state []
    (List
      (Pipeline
        (Com {[LIT_CHARS git]} {[LIT_CHARS for-each-ref]} {[LIT_CHARS --format] [LIT_OTHER "="] [SQ <LIT_CHARS "%(refname) %(objectname)">]} {[LIT_CHARS refs/bisect/] [\ LIT_ESCAPED_CHAR "\\*"]})
        (While
          (Com {[LIT_CHARS read]} {[LIT_CHARS ref]} {[LIT_CHARS hash]})
          (AndOr OP_OR_IF
            (Com {[LIT_CHARS git]} {[LIT_CHARS update-ref]} {[LIT_CHARS -d]} {[VarSub ref]} {[VarSub hash]})
            (Com {[LIT_CHARS exit]})
          )
        )
      )
      (AndOr OP_AND_IF
        (Com {[LIT_CHARS rm]} {[LIT_CHARS -f]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_EXPECTED_REV]]})
        (AndOr OP_AND_IF
          (Com {[LIT_CHARS rm]} {[LIT_CHARS -f]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_ANCESTORS_OK]]})
          (AndOr OP_AND_IF
            (Com {[LIT_CHARS rm]} {[LIT_CHARS -f]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_LOG]]})
            (AndOr OP_AND_IF
              (Com {[LIT_CHARS rm]} {[LIT_CHARS -f]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_NAMES]]})
              (AndOr OP_AND_IF
                (Com {[LIT_CHARS rm]} {[LIT_CHARS -f]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_RUN]]})
                (AndOr OP_AND_IF
                  (Com {[LIT_CHARS rm]} {[LIT_CHARS -f]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_TERMS]]})
                  (AndOr OP_AND_IF
                    (Com {[LIT_CHARS rm]} {[LIT_CHARS -f]} {[DQ [VarSub GIT_DIR][LIT_CHARS /head-name]]})
                    (AndOr OP_AND_IF
                      (Com {[LIT_CHARS git]} {[LIT_CHARS update-ref]} {[LIT_CHARS -d]} {[LIT_CHARS --no-deref]} {[LIT_CHARS BISECT_HEAD]})
                      (Com {[LIT_CHARS rm]} {[LIT_CHARS -f]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_START]]})
                    )
                  )
                )
              )
            )
          )
        )
      )
    )
  )
  (FunctionDef bisect_replay []
    (List
      (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('file', {[DQ [VarSub 1]]})])
      (AndOr OP_OR_IF
        (Com {[LIT_CHARS test]} {[DQ [VarSub #]]} {[LIT_CHARS -eq]} {[LIT_CHARS 1]})
        (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS gettext]} {[DQ [LIT_CHARS "No logfile given"]]})]]})
      )
      (AndOr OP_OR_IF
        (Com {[LIT_CHARS test]} {[LIT_CHARS -r]} {[DQ [VarSub file]]})
        (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS eval_gettext]} {[DQ [LIT_CHARS "cannot read "][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS "file for replaying"]]})]]})
      )
      (Com {[LIT_CHARS bisect_reset]})
      (While
        (Com {[LIT_CHARS read]} {[LIT_CHARS git]} {[LIT_CHARS bisect]} {[LIT_CHARS command]} {[LIT_CHARS rev]})
        (List
          (AndOr OP_OR_IF
            (Com {[LIT_CHARS test]} {[DQ [VarSub git][LIT_CHARS " "][VarSub bisect]]} {[LIT_OTHER "="]} {[DQ [LIT_CHARS "git bisect"]]})
            (AndOr OP_OR_IF
              (Com {[LIT_CHARS test]} {[DQ [VarSub git]]} {[LIT_OTHER "="]} {[DQ [LIT_CHARS git-bisect]]})
              (Com {[LIT_CHARS continue]})
            )
          )
          (If
            (Com {[LIT_CHARS test]} {[DQ [VarSub git]]} {[LIT_OTHER "="]} {[DQ [LIT_CHARS git-bisect]]})
            (List
              (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('rev', {[DQ [VarSub command]]})])
              (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('command', {[DQ [VarSub bisect]]})])
            )
          )
          (Com {[LIT_CHARS get_terms]})
          (Com {[LIT_CHARS check_and_set_terms]} {[DQ [VarSub command]]})
          (Case to_match={[DQ [VarSub command]]}, pat_word_list=[[{[LIT_CHARS start]}], [{[DQ [VarSub TERM_GOOD]]}, {[DQ [VarSub TERM_BAD]]}, {[LIT_CHARS skip]}], [{[LIT_CHARS terms]}], [{[LIT_OTHER "*"]}]]
            (List
              (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('cmd', {[DQ [LIT_CHARS "bisect_start "][VarSub rev]]})])
              (Com {[LIT_CHARS eval]} {[DQ [VarSub cmd]]})
            )
            (Com {[LIT_CHARS bisect_write]} {[DQ [VarSub command]]} {[DQ [VarSub rev]]})
            (Com {[LIT_CHARS bisect_terms]} {[VarSub rev]})
            (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS gettext]} {[DQ [LIT_CHARS "?? what are you talking about?"]]})]]})
          )
        )
      )
      (Com {[LIT_CHARS bisect_auto_next]})
    )
  )
  (FunctionDef bisect_run []
    (List
      (Com {[LIT_CHARS bisect_next_check]} {[LIT_CHARS fail]})
      (While
        (Com {[LIT_CHARS true]})
        (List
          (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('command', {[DQ [VarSub @]]})])
          (Com {[LIT_CHARS eval_gettextln]} {[DQ [LIT_CHARS "running "][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS command]]})
          (Com {[DQ [VarSub @]]})
          (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('res', {[VarSub ?]})])
          (If
            (Com {[LIT_OTHER "["]} {[VarSub res]} {[LIT_CHARS -lt]} {[LIT_CHARS 0]} {[LIT_CHARS -o]} {[VarSub res]} {[LIT_CHARS -ge]} {[LIT_CHARS 128]} {[LIT_OTHER "]"]})
            (List
              (Com {[LIT_CHARS eval_gettextln]} {[DQ [LIT_CHARS "bisect run failed:\n"][LIT_CHARS "exit code "][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS "res from '"][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS "command' is < 0 or >= 128"]]}
                <
                (DescriptorRedirectNode target={[LIT_CHARS 2]} <REDIR_GREATAND ">&"> 1),
                >
              )
              (Com {[LIT_CHARS exit]} {[VarSub res]})
            )
          )
          (If
            (Com {[LIT_OTHER "["]} {[VarSub res]} {[LIT_CHARS -eq]} {[LIT_CHARS 125]} {[LIT_OTHER "]"]})
            (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('state', {[SQ <LIT_CHARS skip>]})])
            (Com {[LIT_OTHER "["]} {[VarSub res]} {[LIT_CHARS -gt]} {[LIT_CHARS 0]} {[LIT_OTHER "]"]})
            (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('state', {[DQ [VarSub TERM_BAD]]})])
            (ElseTrue)
            (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('state', {[DQ [VarSub TERM_GOOD]]})])
          )
          (Subshell
            (Com {[LIT_CHARS bisect_state]} {[VarSub state]}
              <
              (FilenameRedirectNode filename={[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_RUN]]} <REDIR_GREAT ">"> 1),
              >
            )
          )
          (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('res', {[VarSub ?]})])
          (Com {[LIT_CHARS cat]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_RUN]]})
          (If
            (Com {[LIT_CHARS sane_grep]} {[DQ [LIT_CHARS "first "][VarSub TERM_BAD][LIT_CHARS " commit could be any of"]]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_RUN]]}
              <
              (FilenameRedirectNode filename={[LIT_CHARS /dev/null]} <REDIR_GREAT ">"> 1),
              >
            )
            (List
              (Com {[LIT_CHARS gettextln]} {[DQ [LIT_CHARS "bisect run cannot continue any more"]]}
                <
                (DescriptorRedirectNode target={[LIT_CHARS 2]} <REDIR_GREATAND ">&"> 1),
                >
              )
              (Com {[LIT_CHARS exit]} {[VarSub res]})
            )
          )
          (If
            (Com {[LIT_OTHER "["]} {[VarSub res]} {[LIT_CHARS -ne]} {[LIT_CHARS 0]} {[LIT_OTHER "]"]})
            (List
              (Com {[LIT_CHARS eval_gettextln]} {[DQ [LIT_CHARS "bisect run failed:\n"][LIT_CHARS "'bisect_state "][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS "state' exited with error code "][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS res]]}
                <
                (DescriptorRedirectNode target={[LIT_CHARS 2]} <REDIR_GREATAND ">&"> 1),
                >
              )
              (Com {[LIT_CHARS exit]} {[VarSub res]})
            )
          )
          (If
            (Com {[LIT_CHARS sane_grep]} {[DQ [LIT_CHARS "is the first "][VarSub TERM_BAD][LIT_CHARS " commit"]]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_RUN]]}
              <
              (FilenameRedirectNode filename={[LIT_CHARS /dev/null]} <REDIR_GREAT ">"> 1),
              >
            )
            (List
              (Com {[LIT_CHARS gettextln]} {[DQ [LIT_CHARS "bisect run success"]]})
              (Com {[LIT_CHARS exit]} {[LIT_CHARS 0]})
            )
          )
        )
      )
    )
  )
  (FunctionDef bisect_log []
    (List
      (AndOr OP_OR_IF
        (Com {[LIT_CHARS test]} {[LIT_CHARS -s]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_LOG]]})
        (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS gettext]} {[DQ [LIT_CHARS "We are not bisecting."]]})]]})
      )
      (Com {[LIT_CHARS cat]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_LOG]]})
    )
  )
  (FunctionDef get_terms []
    (If
      (Com {[LIT_CHARS test]} {[LIT_CHARS -s]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_TERMS]]})
      (List redirects=[(FilenameRedirectNode filename={[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_TERMS]]} <REDIR_LESS "<"> 0)]
        (Com {[LIT_CHARS read]} {[LIT_CHARS TERM_BAD]})
        (Com {[LIT_CHARS read]} {[LIT_CHARS TERM_GOOD]})
      )
    )
  )
  (FunctionDef write_terms []
    (List
      (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('TERM_BAD', {[VarSub 1]})])
      (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('TERM_GOOD', {[VarSub 2]})])
      (If
        (Com {[LIT_CHARS test]} {[DQ [VarSub TERM_BAD]]} {[LIT_OTHER "="]} {[DQ [VarSub TERM_GOOD]]})
        (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS gettext]} {[DQ [LIT_CHARS "please use two different terms"]]})]]})
      )
      (Com {[LIT_CHARS check_term_format]} {[DQ [VarSub TERM_BAD]]} {[LIT_CHARS bad]})
      (Com {[LIT_CHARS check_term_format]} {[DQ [VarSub TERM_GOOD]]} {[LIT_CHARS good]})
      (Com {[LIT_CHARS printf]} {[SQ <LIT_CHARS "%s\\n%s\\n">]} {[DQ [VarSub TERM_BAD]]} {[DQ [VarSub TERM_GOOD]]}
        <
        (FilenameRedirectNode filename={[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_TERMS]]} <REDIR_GREAT ">"> 1),
        >
      )
    )
  )
  (FunctionDef check_term_format []
    (List
      (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('term', {[VarSub 1]})])
      (AndOr OP_OR_IF
        (Com {[LIT_CHARS git]} {[LIT_CHARS check-ref-format]} {[LIT_CHARS refs/bisect/] [DQ [VarSub term]]})
        (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS eval_gettext]} {[DQ [LIT_CHARS "'"][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS "term' is not a valid term"]]})]]})
      )
      (Case to_match={[DQ [VarSub term]]}, pat_word_list=[[{[LIT_CHARS help]}, {[LIT_CHARS start]}, {[LIT_CHARS terms]}, {[LIT_CHARS skip]}, {[LIT_CHARS next]}, {[LIT_CHARS reset]}, {[LIT_CHARS visualize]}, {[LIT_CHARS replay]}, {[LIT_CHARS log]}, {[LIT_CHARS run]}], [{[LIT_CHARS bad]}, {[LIT_CHARS new]}], [{[LIT_CHARS good]}, {[LIT_CHARS old]}]]
        (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS eval_gettext]} {[DQ [LIT_CHARS "can't use the builtin command '"][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS "term' as a term"]]})]]})
        (If
          (Com {[LIT_CHARS test]} {[DQ [VarSub 2]]} {[LIT_OTHER "!"] [LIT_OTHER "="]} {[LIT_CHARS bad]})
          (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS eval_gettext]} {[DQ [LIT_CHARS "can't change the meaning of term '"][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS "term'"]]})]]})
        )
        (If
          (Com {[LIT_CHARS test]} {[DQ [VarSub 2]]} {[LIT_OTHER "!"] [LIT_OTHER "="]} {[LIT_CHARS good]})
          (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS eval_gettext]} {[DQ [LIT_CHARS "can't change the meaning of term '"][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS "term'"]]})]]})
        )
      )
    )
  )
  (FunctionDef check_and_set_terms []
    (List
      (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('cmd', {[DQ [VarSub 1]]})])
      (Case to_match={[DQ [VarSub cmd]]}, pat_word_list=[[{[LIT_CHARS skip]}, {[LIT_CHARS start]}, {[LIT_CHARS terms]}], [{[LIT_OTHER "*"]}]]
        (ElseTrue)
        (List
          (If
            (AndOr OP_AND_IF
              (Com {[LIT_CHARS test]} {[LIT_CHARS -s]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_TERMS]]})
              (AndOr OP_AND_IF
                (Com {[LIT_CHARS test]} {[DQ [VarSub cmd]]} {[LIT_OTHER "!"] [LIT_OTHER "="]} {[DQ [VarSub TERM_BAD]]})
                (Com {[LIT_CHARS test]} {[DQ [VarSub cmd]]} {[LIT_OTHER "!"] [LIT_OTHER "="]} {[DQ [VarSub TERM_GOOD]]})
              )
            )
            (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS eval_gettext]} {[DQ [LIT_CHARS "Invalid command: you're currently in a "][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS TERM_BAD/][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS "TERM_GOOD bisect."]]})]]})
          )
          (Case to_match={[DQ [VarSub cmd]]}, pat_word_list=[[{[LIT_CHARS bad]}, {[LIT_CHARS good]}], [{[LIT_CHARS new]}, {[LIT_CHARS old]}]]
            (If
              (Pipeline!
                (Com {[LIT_CHARS test]} {[LIT_CHARS -s]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_TERMS]]})
              )
              (Com {[LIT_CHARS write_terms]} {[LIT_CHARS bad]} {[LIT_CHARS good]})
            )
            (If
              (Pipeline!
                (Com {[LIT_CHARS test]} {[LIT_CHARS -s]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_TERMS]]})
              )
              (Com {[LIT_CHARS write_terms]} {[LIT_CHARS new]} {[LIT_CHARS old]})
            )
          )
        )
      )
    )
  )
  (FunctionDef bisect_voc []
    (Case to_match={[DQ [VarSub 1]]}, pat_word_list=[[{[LIT_CHARS bad]}], [{[LIT_CHARS good]}]]
      (Com {[LIT_CHARS echo]} {[DQ [LIT_CHARS "bad|new"]]})
      (Com {[LIT_CHARS echo]} {[DQ [LIT_CHARS "good|old"]]})
    )
  )
  (FunctionDef bisect_terms []
    (List
      (Com {[LIT_CHARS get_terms]})
      (If
        (Pipeline!
          (Com {[LIT_CHARS test]} {[LIT_CHARS -s]} {[DQ [VarSub GIT_DIR][LIT_CHARS /BISECT_TERMS]]})
        )
        (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS gettext]} {[DQ [LIT_CHARS "no terms defined"]]})]]})
      )
      (Case to_match={[DQ [VarSub #]]}, pat_word_list=[[{[LIT_CHARS 0]}], [{[LIT_CHARS 1]}], [{[LIT_OTHER "*"]}]]
        (Com {[LIT_CHARS gettextln]} {[DQ [LIT_CHARS "Your current terms are "][VarSub TERM_GOOD][LIT_CHARS " for the old state\n"][LIT_CHARS "and "][VarSub TERM_BAD][LIT_CHARS " for the new state."]]})
        (List
          (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('arg', {[VarSub 1]})])
          (Case to_match={[DQ [VarSub arg]]}, pat_word_list=[[{[LIT_CHARS --term-good]}, {[LIT_CHARS --term-old]}], [{[LIT_CHARS --term-bad]}, {[LIT_CHARS --term-new]}], [{[LIT_OTHER "*"]}]]
            (Com {[LIT_CHARS printf]} {[SQ <LIT_CHARS "%s\\n">]} {[DQ [VarSub TERM_GOOD]]})
            (Com {[LIT_CHARS printf]} {[SQ <LIT_CHARS "%s\\n">]} {[DQ [VarSub TERM_BAD]]})
            (Com {[LIT_CHARS die]} {[DQ [ComSub (Com {[LIT_CHARS eval_gettext]} {[DQ [LIT_CHARS "invalid argument "][\ LIT_ESCAPED_CHAR "\\$"][LIT_CHARS "arg for 'git bisect terms'.\n"][LIT_CHARS "Supported options are: --term-good|--term-old and --term-bad|--term-new."]]})]]})
          )
        )
        (Com {[LIT_CHARS usage]})
      )
    )
  )
  (Case to_match={[DQ [VarSub #]]}, pat_word_list=[[{[LIT_CHARS 0]}], [{[LIT_OTHER "*"]}]]
    (Com {[LIT_CHARS usage]})
    (List
      (= scope=<EAssignScope.GLOBAL 1> flags=0 words=[] bindings=[('cmd', {[DQ [VarSub 1]]})])
      (Com {[LIT_CHARS get_terms]})
      (Com {[LIT_CHARS shift]})
      (Case to_match={[DQ [VarSub cmd]]}, pat_word_list=[[{[LIT_CHARS help]}], [{[LIT_CHARS start]}], [{[LIT_CHARS bad]}, {[LIT_CHARS good]}, {[LIT_CHARS new]}, {[LIT_CHARS old]}, {[DQ [VarSub TERM_BAD]]}, {[DQ [VarSub TERM_GOOD]]}], [{[LIT_CHARS skip]}], [{[LIT_CHARS next]}], [{[LIT_CHARS visualize]}, {[LIT_CHARS view]}], [{[LIT_CHARS reset]}], [{[LIT_CHARS replay]}], [{[LIT_CHARS log]}], [{[LIT_CHARS run]}], [{[LIT_CHARS terms]}], [{[LIT_OTHER "*"]}]]
        (Com {[LIT_CHARS git]} {[LIT_CHARS bisect]} {[LIT_CHARS -h]})
        (Com {[LIT_CHARS bisect_start]} {[DQ [VarSub @]]})
        (Com {[LIT_CHARS bisect_state]} {[DQ [VarSub cmd]]} {[DQ [VarSub @]]})
        (Com {[LIT_CHARS bisect_skip]} {[DQ [VarSub @]]})
        (Com {[LIT_CHARS bisect_next]} {[DQ [VarSub @]]})
        (Com {[LIT_CHARS bisect_visualize]} {[DQ [VarSub @]]})
        (Com {[LIT_CHARS bisect_reset]} {[DQ [VarSub @]]})
        (Com {[LIT_CHARS bisect_replay]} {[DQ [VarSub @]]})
        (Com {[LIT_CHARS bisect_log]})
        (Com {[LIT_CHARS bisect_run]} {[DQ [VarSub @]]})
        (Com {[LIT_CHARS bisect_terms]} {[DQ [VarSub @]]})
        (Com {[LIT_CHARS usage]})
      )
    )
  )
)