(CommandList
  children: [
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$TEST_DIRECTORY"))})]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:TEST_DIRECTORY)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(pwd)})])
                        left_token: <Left_CommandSub "$(">
                        spids: [81 83]
                      )
                    }
                  spids: [80]
                )
              ]
              spids: [80]
            )
          ]
          spids: [-1 65]
        )
      ]
      else_action: [
        (AndOr
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:TEST_DIRECTORY)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (AndOr
                                children: [(C {(cd)} {(DQ ($ VSub_Name "$TEST_DIRECTORY"))}) (C {(pwd)})]
                                op_id: Op_DAmp
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [97 107]
                      )
                    }
                  spids: [96]
                )
              ]
              spids: [96]
            )
            (C {(exit)} {(1)})
          ]
          op_id: Op_DPipe
        )
      ]
      spids: [85 115]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$TEST_OUTPUT_DIRECTORY"))})]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:TEST_OUTPUT_DIRECTORY)
                  op: Equal
                  rhs: {($ VSub_Name "$TEST_DIRECTORY")}
                  spids: [138]
                )
              ]
              spids: [138]
            )
          ]
          spids: [-1 127]
        )
      ]
      spids: [-1 141]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:GIT_BUILD_DIR)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$TEST_DIRECTORY")) (/..)}
          spids: [143]
        )
      ]
      spids: [143]
    )
    (SimpleCommand
      words: [{(DQ ($ VSub_Name "$GIT_BUILD_DIR") (/git))}]
      redirects: [(Redir op_id:Redir_Great fd:-1 arg_word:{(/dev/null)} spids:[161])]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {($ VSub_QMark "$?")} {(KW_Bang "!") (Lit_Other "=")} {(1)})]
          action: [
            (SimpleCommand
              words: [{(echo)} {(SQ <"error: you do not seem to have built git yet.">)}]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[180])]
            )
            (C {(exit)} {(1)})
          ]
          spids: [-1 175]
        )
      ]
      spids: [-1 192]
    )
    (C {(.)} {(DQ ($ VSub_Name "$GIT_BUILD_DIR")) (/GIT-BUILD-OPTIONS)})
    (C {(export)} {(PERL_PATH)} {(SHELL_PATH)})
    (Case
      to_match: {(DQ ($ VSub_Name "$GIT_TEST_TEE_STARTED") (", ") ($ VSub_Star "$*") (" "))}
      arms: [
        (case_arm
          pat_list: [{(KW_Done done) (Lit_Comma ",") (Lit_Other "*")}]
          spids: [226 229 236 -1]
        )
        (case_arm
          pat_list: [
            {(Lit_Other "*") (SQ <" --tee ">) (Lit_Other "*")}
            {(Lit_Other "*") (SQ <" --va">) (Lit_Other "*")}
            {(Lit_Other "*") (SQ <" --verbose-log ">) (Lit_Other "*")}
          ]
          action: [
            (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$TEST_OUTPUT_DIRECTORY") (/test-results))})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:BASE)
                  op: Equal
                  rhs: 
                    {
                      (DQ ($ VSub_Name "$TEST_OUTPUT_DIRECTORY") (/test-results/) 
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [(C {(basename)} {(DQ ($ VSub_Number "$0"))} {(.sh)})]
                            )
                          left_token: <Left_CommandSub "$(">
                          spids: [272 280]
                        )
                      )
                    }
                  spids: [268]
                )
              ]
              spids: [268]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:GIT_TEST_TEE_OUTPUT_FILE)
                  op: Equal
                  rhs: {($ VSub_Name "$BASE") (.out)}
                  spids: [293]
                )
              ]
              spids: [293]
            )
            (C {(export)} {(GIT_TEST_TEE_OUTPUT_FILE)})
            (SimpleCommand
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$GIT_TEST_TEE_OUTPUT_FILE"))}
                  spids: [312]
                )
              ]
            )
            (Pipeline
              children: [
                (Subshell
                  child: 
                    (CommandList
                      children: [
                        (Sentence
                          child: 
                            (SimpleCommand
                              words: [
                                {(${ VSub_Name SHELL_PATH)}
                                {(DQ ($ VSub_Number "$0"))}
                                {(DQ ($ VSub_At "$@"))}
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 2
                                  arg_word: {(1)}
                                  spids: [335]
                                )
                              ]
                              more_env: [
                                (env_pair
                                  name: GIT_TEST_TEE_STARTED
                                  val: {(KW_Done done)}
                                  spids: [320]
                                )
                              ]
                            )
                          terminator: <Op_Semi ";">
                        )
                        (SimpleCommand
                          words: [{(echo)} {($ VSub_QMark "$?")}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: -1
                              arg_word: {(DQ ($ VSub_Name "$BASE") (.exit))}
                              spids: [344]
                            )
                          ]
                        )
                      ]
                    )
                  spids: [319 349]
                )
                (C {(tee)} {(-a)} {(DQ ($ VSub_Name "$GIT_TEST_TEE_OUTPUT_FILE"))})
              ]
              negated: False
            )
            (C {(test)} 
              {
                (DQ 
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [(C {(cat)} {(DQ ($ VSub_Name "$BASE") (.exit))})]
                      )
                    left_token: <Left_CommandSub "$(">
                    spids: [365 372]
                  )
                )
              } {(Lit_Other "=")} {(0)}
            )
            (C {(exit)})
          ]
          spids: [238 255 383 -1]
        )
      ]
      spids: [215 224 385]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:LANG) op:Equal rhs:{(C)} spids:[394])]
      spids: [394]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:LC_ALL) op:Equal rhs:{(C)} spids:[397])]
      spids: [397]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:PAGER) op:Equal rhs:{(cat)} spids:[400])]
      spids: [400]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:TZ) op:Equal rhs:{(UTC)} spids:[403])]
      spids: [403]
    )
    (C {(export)} {(LANG)} {(LC_ALL)} {(PAGER)} {(TZ)})
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:EDITOR) op:Equal rhs:{(Lit_Other ":")} spids:[416])]
      spids: [416]
    )
    (C {(unset)} {(VISUAL)} {(EMAIL)} {(LANGUAGE)} {(COLUMNS)} 
      {
        (CommandSubPart
          command_list: 
            (CommandList
              children: [
                (C {(DQ ($ VSub_Name "$PERL_PATH"))} {(-e)} 
                  {
                    (SQ <"\n"> <"\tmy @env = keys %ENV;\n"> <"\tmy $ok = join(\"|\", qw(\n"> 
                      <"\t\tTRACE\n"> <"\t\tDEBUG\n"> <"\t\tUSE_LOOKUP\n"> <"\t\tTEST\n"> <"\t\t.*_TEST\n"> <"\t\tPROVE\n"> <"\t\tVALGRIND\n"> 
                      <"\t\tUNZIP\n"> <"\t\tPERF_\n"> <"\t\tCURL_VERBOSE\n"> <"\t\tTRACE_CURL\n"> <"\t));\n"> 
                      <"\tmy @vars = grep(/^GIT_/ && !/^GIT_($ok)/o, @env);\n"> <"\tprint join(\"\\n\", @vars);\n">
                    )
                  }
                )
              ]
            )
          left_token: <Left_CommandSub "$(">
          spids: [441 467]
        )
      }
    )
    (C {(unset)} {(XDG_CONFIG_HOME)})
    (C {(unset)} {(GITPERLLIB)})
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:GIT_AUTHOR_EMAIL)
          op: Equal
          rhs: {(author) (Lit_Other "@") (example.com)}
          spids: [477]
        )
      ]
      spids: [477]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:GIT_AUTHOR_NAME)
          op: Equal
          rhs: {(SQ <"A U Thor">)}
          spids: [482]
        )
      ]
      spids: [482]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:GIT_COMMITTER_EMAIL)
          op: Equal
          rhs: {(committer) (Lit_Other "@") (example.com)}
          spids: [487]
        )
      ]
      spids: [487]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:GIT_COMMITTER_NAME)
          op: Equal
          rhs: {(SQ <"C O Mitter">)}
          spids: [492]
        )
      ]
      spids: [492]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:GIT_MERGE_VERBOSITY) op:Equal rhs:{(5)} spids:[497])]
      spids: [497]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:GIT_MERGE_AUTOEDIT) op:Equal rhs:{(no)} spids:[500])]
      spids: [500]
    )
    (C {(export)} {(GIT_MERGE_VERBOSITY)} {(GIT_MERGE_AUTOEDIT)})
    (C {(export)} {(GIT_AUTHOR_EMAIL)} {(GIT_AUTHOR_NAME)})
    (C {(export)} {(GIT_COMMITTER_EMAIL)} {(GIT_COMMITTER_NAME)})
    (C {(export)} {(EDITOR)})
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:GIT_TRACE_BARE) op:Equal rhs:{(1)} spids:[529])]
      spids: [529]
    )
    (C {(export)} {(GIT_TRACE_BARE)})
    (If
      arms: [
        (if_arm
          cond: [
            (C {(test)} {(-n)} 
              {
                (DQ 
                  (BracedVarSub
                    token: <VSub_Name TEST_GIT_INDEX_VERSION>
                    suffix_op: (StringUnary op_id:VTest_ColonPlus arg_word:{(isset)})
                    spids: [544 548]
                  )
                )
              }
            )
          ]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:GIT_INDEX_VERSION)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$TEST_GIT_INDEX_VERSION"))}
                  spids: [554]
                )
              ]
              spids: [554]
            )
            (C {(export)} {(GIT_INDEX_VERSION)})
          ]
          spids: [-1 551]
        )
      ]
      spids: [-1 564]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (AndOr
              children: [
                (SimpleCommand
                  words: [
                    {(expr)}
                    {(DQ (" ") ($ VSub_Name "$GIT_TEST_OPTS") (" "))}
                    {(Lit_Other ":")}
                    {(DQ (".* --valgrind "))}
                  ]
                  redirects: [(Redir op_id:Redir_Great fd:-1 arg_word:{(/dev/null)} spids:[589])]
                )
                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$TEST_NO_MALLOC_CHECK"))})
              ]
              op_id: Op_DPipe
            )
          ]
          action: [
            (FuncDef
              name: setup_malloc_check
              body: (BraceGroup children:[(C {(Lit_Other ":")} {(nothing)})] spids:[611])
              spids: [606 610]
            )
            (FuncDef
              name: teardown_malloc_check
              body: (BraceGroup children:[(C {(Lit_Other ":")} {(nothing)})] spids:[627])
              spids: [622 626]
            )
          ]
          spids: [-1 603]
        )
      ]
      else_action: [
        (FuncDef
          name: setup_malloc_check
          body: 
            (BraceGroup
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:MALLOC_CHECK_)
                      op: Equal
                      rhs: {(3)}
                      spids: [648]
                    )
                    (assign_pair
                      lhs: (LhsName name:MALLOC_PERTURB_)
                      op: Equal
                      rhs: {(165)}
                      spids: [651]
                    )
                  ]
                  spids: [648]
                )
                (C {(export)} {(MALLOC_CHECK_)} {(MALLOC_PERTURB_)})
              ]
              spids: [645]
            )
          spids: [640 644]
        )
        (FuncDef
          name: teardown_malloc_check
          body: 
            (BraceGroup
              children: [(C {(unset)} {(MALLOC_CHECK_)} {(MALLOC_PERTURB_)})]
              spids: [670]
            )
          spids: [665 669]
        )
      ]
      spids: [637 682]
    )
    (C {(Lit_Other ":")} 
      {
        (BracedVarSub
          token: <VSub_Name ASAN_OPTIONS>
          suffix_op: (StringUnary op_id:VTest_Equals arg_word:{("detect_leaks=0")})
          spids: [687 691]
        )
      }
    )
    (C {(export)} {(ASAN_OPTIONS)})
    (C {(unset)} {(CDPATH)})
    (C {(unset)} {(GREP_OPTIONS)})
    (C {(unset)} {(UNZIP)})
    (Case
      to_match: 
        {
          (CommandSubPart
            command_list: 
              (CommandList
                children: [
                  (Pipeline
                    children: [
                      (C {(echo)} {($ VSub_Name "$GIT_TRACE")})
                      (C {(tr)} {(DQ ("[A-Z]"))} {(DQ ("[a-z]"))})
                    ]
                    negated: False
                  )
                ]
              )
            left_token: <Left_CommandSub "$(">
            spids: [720 735]
          )
        }
      arms: [
        (case_arm
          pat_list: [{(1)} {(2)} {(true)}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:GIT_TRACE) op:Equal rhs:{(4)} spids:[747])]
              spids: [747]
            )
          ]
          spids: [739 744 751 -1]
        )
      ]
      spids: [718 737 753]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_x05)
          op: Equal
          rhs: {(SQ <"[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]">)}
          spids: [765]
        )
      ]
      spids: [765]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_x40)
          op: Equal
          rhs: 
            {
              (DQ ($ VSub_Name "$_x05") ($ VSub_Name "$_x05") ($ VSub_Name "$_x05") 
                ($ VSub_Name "$_x05") ($ VSub_Name "$_x05") ($ VSub_Name "$_x05") ($ VSub_Name "$_x05") ($ VSub_Name "$_x05")
              )
            }
          spids: [770]
        )
      ]
      spids: [770]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_z40)
          op: Equal
          rhs: {(0000000000000000000000000000000000000000)}
          spids: [786]
        )
      ]
      spids: [786]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:EMPTY_TREE)
          op: Equal
          rhs: {(4b825dc642cb6eb9a060e54bf8d69288fbee4904)}
          spids: [790]
        )
      ]
      spids: [790]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:EMPTY_BLOB)
          op: Equal
          rhs: {(e69de29bb2d1d6434b8b29ae775ad8c2e48c5391)}
          spids: [793]
        )
      ]
      spids: [793]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:LF) op:Equal rhs:{(SQ <"\n">)} spids:[800])]
      spids: [800]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:u200c)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: (CommandList children:[(C {(printf)} {(SQ <"\\342\\200\\214">)})])
                left_token: <Left_CommandSub "$(">
                spids: [813 819]
              )
            }
          spids: [812]
        )
      ]
      spids: [812]
    )
    (C {(export)} {(_x05)} {(_x40)} {(_z40)} {(LF)} {(u200c)} {(EMPTY_TREE)} {(EMPTY_BLOB)})
    (AndOr
      children: [
        (C {(test)} {(DQ (x) ($ VSub_Name "$TERM"))} {(KW_Bang "!") (Lit_Other "=")} {(DQ (xdumb))})
        (AndOr
          children: [
            (Subshell
              child: 
                (AndOr
                  children: [
                    (C {(test)} {(-t)} {(1)})
                    (AndOr
                      children: [
                        (SimpleCommand
                          words: [{(tput)} {(bold)}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: -1
                              arg_word: {(/dev/null)}
                              spids: [889]
                            )
                            (Redir
                              op_id: Redir_GreatAnd
                              fd: 2
                              arg_word: {(1)}
                              spids: [892]
                            )
                          ]
                        )
                        (AndOr
                          children: [
                            (SimpleCommand
                              words: [{(tput)} {(setaf)} {(1)}]
                              redirects: [
                                (Redir
                                  op_id: Redir_Great
                                  fd: -1
                                  arg_word: {(/dev/null)}
                                  spids: [904]
                                )
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 2
                                  arg_word: {(1)}
                                  spids: [907]
                                )
                              ]
                            )
                            (SimpleCommand
                              words: [{(tput)} {(sgr0)}]
                              redirects: [
                                (Redir
                                  op_id: Redir_Great
                                  fd: -1
                                  arg_word: {(/dev/null)}
                                  spids: [917]
                                )
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 2
                                  arg_word: {(1)}
                                  spids: [920]
                                )
                              ]
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  op_id: Op_DAmp
                )
              spids: [873 924]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:color) op:Equal rhs:{(t)} spids:[929])]
              spids: [929]
            )
          ]
          op_id: Op_DAmp
        )
      ]
      op_id: Op_DAmp
    )
    (While
      cond: [(C {(test)} {(DQ ($ VSub_Pound "$#"))} {(-ne)} {(0)})]
      body: 
        (DoGroup
          children: [
            (Case
              to_match: {(DQ ($ VSub_Number "$1"))}
              arms: [
                (case_arm
                  pat_list: [{(-d)} {(--d)} {(--de)} {(--deb)} {(--debu)} {(--debug)}]
                  action: [
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:debug)
                              op: Equal
                              rhs: {(t)}
                              spids: [971]
                            )
                          ]
                          spids: [971]
                        )
                      terminator: <Op_Semi ";">
                    )
                    (C {(shift)})
                  ]
                  spids: [957 968 977 -1]
                )
                (case_arm
                  pat_list: [
                    {(-i)}
                    {(--i)}
                    {(--im)}
                    {(--imm)}
                    {(--imme)}
                    {(--immed)}
                    {(--immedi)}
                    {(--immedia)}
                    {(--immediat)}
                    {(--immediate)}
                  ]
                  action: [
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:immediate)
                              op: Equal
                              rhs: {(t)}
                              spids: [1002]
                            )
                          ]
                          spids: [1002]
                        )
                      terminator: <Op_Semi ";">
                    )
                    (C {(shift)})
                  ]
                  spids: [980 999 1008 -1]
                )
                (case_arm
                  pat_list: [
                    {(-l)}
                    {(--l)}
                    {(--lo)}
                    {(--lon)}
                    {(--long)}
                    {(--long-)}
                    {(--long-t)}
                    {(--long-te)}
                    {(--long-tes)}
                    {(--long-test)}
                    {(--long-tests)}
                  ]
                  action: [
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:GIT_TEST_LONG)
                              op: Equal
                              rhs: {(t)}
                              spids: [1035]
                            )
                          ]
                          spids: [1035]
                        )
                      terminator: <Op_Semi ";">
                    )
                    (Sentence
                      child: (C {(export)} {(GIT_TEST_LONG)})
                      terminator: <Op_Semi ";">
                    )
                    (C {(shift)})
                  ]
                  spids: [1011 1032 1046 -1]
                )
                (case_arm
                  pat_list: [{(-r)}]
                  action: [
                    (Sentence child:(C {(shift)}) terminator:<Op_Semi ";">)
                    (AndOr
                      children: [
                        (C {(test)} {(DQ ($ VSub_Pound "$#"))} {(-ne)} {(0)})
                        (BraceGroup
                          children: [
                            (Sentence
                              child: 
                                (SimpleCommand
                                  words: [{(echo)} {(SQ <"error: -r requires an argument">)}]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_GreatAnd
                                      fd: -1
                                      arg_word: {(2)}
                                      spids: [1077]
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ";">
                            )
                            (Sentence
                              child: (C {(exit)} {(1)})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          spids: [1068]
                        )
                      ]
                      op_id: Op_DPipe
                    )
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:run_list)
                              op: Equal
                              rhs: {($ VSub_Number "$1")}
                              spids: [1091]
                            )
                          ]
                          spids: [1091]
                        )
                      terminator: <Op_Semi ";">
                    )
                    (C {(shift)})
                  ]
                  spids: [1049 1050 1097 -1]
                )
                (case_arm
                  pat_list: [{(--run) (Lit_Other "=") (Lit_Other "*")}]
                  action: [
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:run_list)
                              op: Equal
                              rhs: 
                                {
                                  (BracedVarSub
                                    token: <VSub_Number 1>
                                    suffix_op: (StringUnary op_id:VOp1_Pound arg_word:{("--*=")})
                                    spids: [1107 1111]
                                  )
                                }
                              spids: [1106]
                            )
                          ]
                          spids: [1106]
                        )
                      terminator: <Op_Semi ";">
                    )
                    (C {(shift)})
                  ]
                  spids: [1100 1103 1116 -1]
                )
                (case_arm
                  pat_list: [{(-h)} {(--h)} {(--he)} {(--hel)} {(--help)}]
                  action: [
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:help)
                              op: Equal
                              rhs: {(t)}
                              spids: [1131]
                            )
                          ]
                          spids: [1131]
                        )
                      terminator: <Op_Semi ";">
                    )
                    (C {(shift)})
                  ]
                  spids: [1119 1128 1137 -1]
                )
                (case_arm
                  pat_list: [
                    {(-v)}
                    {(--v)}
                    {(--ve)}
                    {(--ver)}
                    {(--verb)}
                    {(--verbo)}
                    {(--verbos)}
                    {(--verbose)}
                  ]
                  action: [
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:verbose)
                              op: Equal
                              rhs: {(t)}
                              spids: [1158]
                            )
                          ]
                          spids: [1158]
                        )
                      terminator: <Op_Semi ";">
                    )
                    (C {(shift)})
                  ]
                  spids: [1140 1155 1164 -1]
                )
                (case_arm
                  pat_list: [{(--verbose-only) (Lit_Other "=") (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:verbose_only)
                          op: Equal
                          rhs: 
                            {
                              (BracedVarSub
                                token: <VSub_Number 1>
                                suffix_op: (StringUnary op_id:VOp1_Pound arg_word:{("--*=")})
                                spids: [1174 1178]
                              )
                            }
                          spids: [1173]
                        )
                      ]
                      spids: [1173]
                    )
                    (C {(shift)})
                  ]
                  spids: [1167 1170 1183 -1]
                )
                (case_arm
                  pat_list: [{(-q)} {(--q)} {(--qu)} {(--qui)} {(--quie)} {(--quiet)}]
                  action: [
                    (Sentence
                      child: 
                        (AndOr
                          children: [
                            (C {(test)} {(-z)} {(DQ ($ VSub_Name "$HARNESS_ACTIVE"))})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:quiet)
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1218]
                                )
                              ]
                              spids: [1218]
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      terminator: <Op_Semi ";">
                    )
                    (C {(shift)})
                  ]
                  spids: [1186 1197 1224 -1]
                )
                (case_arm
                  pat_list: [{(--with-dashes)}]
                  action: [
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:with_dashes)
                              op: Equal
                              rhs: {(t)}
                              spids: [1231]
                            )
                          ]
                          spids: [1231]
                        )
                      terminator: <Op_Semi ";">
                    )
                    (C {(shift)})
                  ]
                  spids: [1227 1228 1237 -1]
                )
                (case_arm
                  pat_list: [{(--no-color)}]
                  action: [
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:color)
                              op: Equal
                              rhs: {(SQ )}
                              spids: [1244]
                            )
                          ]
                          spids: [1244]
                        )
                      terminator: <Op_Semi ";">
                    )
                    (C {(shift)})
                  ]
                  spids: [1240 1241 1249 -1]
                )
                (case_arm
                  pat_list: [
                    {(--va)}
                    {(--val)}
                    {(--valg)}
                    {(--valgr)}
                    {(--valgri)}
                    {(--valgrin)}
                    {(--valgrind)}
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:valgrind)
                          op: Equal
                          rhs: {(memcheck)}
                          spids: [1268]
                        )
                      ]
                      spids: [1268]
                    )
                    (C {(shift)})
                  ]
                  spids: [1252 1265 1274 -1]
                )
                (case_arm
                  pat_list: [{(--valgrind) (Lit_Other "=") (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:valgrind)
                          op: Equal
                          rhs: 
                            {
                              (BracedVarSub
                                token: <VSub_Number 1>
                                suffix_op: (StringUnary op_id:VOp1_Pound arg_word:{("--*=")})
                                spids: [1284 1288]
                              )
                            }
                          spids: [1283]
                        )
                      ]
                      spids: [1283]
                    )
                    (C {(shift)})
                  ]
                  spids: [1277 1280 1293 -1]
                )
                (case_arm
                  pat_list: [{(--valgrind-only) (Lit_Other "=") (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:valgrind_only)
                          op: Equal
                          rhs: 
                            {
                              (BracedVarSub
                                token: <VSub_Number 1>
                                suffix_op: (StringUnary op_id:VOp1_Pound arg_word:{("--*=")})
                                spids: [1303 1307]
                              )
                            }
                          spids: [1302]
                        )
                      ]
                      spids: [1302]
                    )
                    (C {(shift)})
                  ]
                  spids: [1296 1299 1312 -1]
                )
                (case_arm
                  pat_list: [{(--tee)}]
                  action: [(C {(shift)})]
                  spids: [1315 1316 1321 -1]
                )
                (case_arm
                  pat_list: [{(--root) (Lit_Other "=") (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:root)
                          op: Equal
                          rhs: 
                            {
                              (BracedVarSub
                                token: <VSub_Number 1>
                                suffix_op: (StringUnary op_id:VOp1_Pound arg_word:{("--*=")})
                                spids: [1334 1338]
                              )
                            }
                          spids: [1333]
                        )
                      ]
                      spids: [1333]
                    )
                    (C {(shift)})
                  ]
                  spids: [1327 1330 1343 -1]
                )
                (case_arm
                  pat_list: [{(--chain-lint)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:GIT_TEST_CHAIN_LINT)
                          op: Equal
                          rhs: {(1)}
                          spids: [1350]
                        )
                      ]
                      spids: [1350]
                    )
                    (C {(shift)})
                  ]
                  spids: [1346 1347 1356 -1]
                )
                (case_arm
                  pat_list: [{(--no-chain-lint)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:GIT_TEST_CHAIN_LINT)
                          op: Equal
                          rhs: {(0)}
                          spids: [1363]
                        )
                      ]
                      spids: [1363]
                    )
                    (C {(shift)})
                  ]
                  spids: [1359 1360 1369 -1]
                )
                (case_arm
                  pat_list: [{(-x)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:trace) op:Equal rhs:{(t)} spids:[1376])]
                      spids: [1376]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:verbose)
                          op: Equal
                          rhs: {(t)}
                          spids: [1380]
                        )
                      ]
                      spids: [1380]
                    )
                    (C {(shift)})
                  ]
                  spids: [1372 1373 1386 -1]
                )
                (case_arm
                  pat_list: [{(--verbose-log)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:verbose_log)
                          op: Equal
                          rhs: {(t)}
                          spids: [1393]
                        )
                      ]
                      spids: [1393]
                    )
                    (C {(shift)})
                  ]
                  spids: [1389 1390 1399 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [
                    (Sentence
                      child: 
                        (SimpleCommand
                          words: [
                            {(echo)}
                            {(DQ ("error: unknown test option '") ($ VSub_Number "$1") ("'"))}
                          ]
                          redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[1414])]
                        )
                      terminator: <Op_Semi ";">
                    )
                    (C {(exit)} {(1)})
                  ]
                  spids: [1402 1403 1422 -1]
                )
              ]
              spids: [948 954 1425]
            )
          ]
          spids: [945 1427]
        )
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$valgrind_only"))})]
          action: [
            (AndOr
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$valgrind"))})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:valgrind)
                      op: Equal
                      rhs: {(memcheck)}
                      spids: [1453]
                    )
                  ]
                  spids: [1453]
                )
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$verbose"))})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:verbose_only)
                      op: Equal
                      rhs: {(DQ ($ VSub_Name "$valgrind_only"))}
                      spids: [1467]
                    )
                  ]
                  spids: [1467]
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [-1 1440]
        )
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$valgrind"))})]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:verbose) op:Equal rhs:{(t)} spids:[1485])]
              spids: [1485]
            )
          ]
          spids: [1472 1482]
        )
      ]
      spids: [-1 1488]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$color"))})]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:say_color_error)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (Sentence
                                child: (C {(tput)} {(bold)})
                                terminator: <Op_Semi ";">
                              )
                              (C {(tput)} {(setaf)} {(1)})
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [1553 1564]
                      )
                    }
                  spids: [1552]
                )
              ]
              spids: [1552]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:say_color_skip)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(tput)} {(setaf)} {(4)})])
                        left_token: <Left_CommandSub "$(">
                        spids: [1571 1577]
                      )
                    }
                  spids: [1570]
                )
              ]
              spids: [1570]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:say_color_warn)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(tput)} {(setaf)} {(3)})])
                        left_token: <Left_CommandSub "$(">
                        spids: [1584 1590]
                      )
                    }
                  spids: [1583]
                )
              ]
              spids: [1583]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:say_color_pass)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(tput)} {(setaf)} {(2)})])
                        left_token: <Left_CommandSub "$(">
                        spids: [1597 1603]
                      )
                    }
                  spids: [1596]
                )
              ]
              spids: [1596]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:say_color_info)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(tput)} {(setaf)} {(6)})])
                        left_token: <Left_CommandSub "$(">
                        spids: [1610 1616]
                      )
                    }
                  spids: [1609]
                )
              ]
              spids: [1609]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:say_color_reset)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(tput)} {(sgr0)})])
                        left_token: <Left_CommandSub "$(">
                        spids: [1623 1627]
                      )
                    }
                  spids: [1622]
                )
              ]
              spids: [1622]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:say_color_) op:Equal rhs:{(DQ )} spids:[1630])]
              spids: [1630]
            )
            (FuncDef
              name: say_color
              body: 
                (BraceGroup
                  children: [
                    (AndOr
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Number "$1"))})
                        (AndOr
                          children: [
                            (C {(test)} {(-n)} {(DQ ($ VSub_Name "$quiet"))})
                            (ControlFlow
                              token: <ControlFlow_Return return>
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (C {(eval)} 
                      {
                        (DQ ("say_color_color=") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                          (say_color_) ($ VSub_Number "$1")
                        )
                      }
                    )
                    (C {(shift)})
                    (C {(printf)} {(DQ ("%s") (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) (n))} 
                      {
                        (DQ ($ VSub_Name "$say_color_color") ($ VSub_Star "$*") 
                          ($ VSub_Name "$say_color_reset")
                        )
                      }
                    )
                  ]
                  spids: [1643]
                )
              spids: [1638 1642]
            )
          ]
          spids: [-1 1501]
        )
      ]
      else_action: [
        (FuncDef
          name: say_color
          body: 
            (BraceGroup
              children: [
                (AndOr
                  children: [
                    (C {(test)} {(-z)} {(DQ ($ VSub_Number "$1"))})
                    (AndOr
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$quiet"))})
                        (ControlFlow token:<ControlFlow_Return return>)
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  op_id: Op_DAmp
                )
                (C {(shift)})
                (C {(printf)} {(DQ ("%s") (EscapedLiteralPart token:<Lit_EscapedChar "\\n">))} 
                  {(DQ ($ VSub_Star "$*"))}
                )
              ]
              spids: [1706]
            )
          spids: [1702 1705]
        )
      ]
      spids: [1699 1749]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:TERM) op:Equal rhs:{(dumb)} spids:[1752])]
      spids: [1752]
    )
    (C {(export)} {(TERM)})
    (FuncDef
      name: error
      body: 
        (BraceGroup
          children: [
            (C {(say_color)} {(error)} {(DQ ("error: ") ($ VSub_Star "$*"))})
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:GIT_EXIT_OK) op:Equal rhs:{(t)} spids:[1778])]
              spids: [1778]
            )
            (C {(exit)} {(1)})
          ]
          spids: [1765]
        )
      spids: [1760 1764]
    )
    (FuncDef
      name: say
      body: (BraceGroup children:[(C {(say_color)} {(info)} {(DQ ($ VSub_Star "$*"))})] spids:[1794])
      spids: [1789 1793]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$HARNESS_ACTIVE"))})]
          action: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(test)} {(DQ ($ VSub_Name "$verbose"))} {(Lit_Other "=")} {(t)})
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$verbose_only"))})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  action: [
                    (C {(printf)} {(SQ <"Bail out! %s\\n">)} 
                      {(SQ <"verbose mode forbidden under TAP harness; try --verbose-log">)}
                    )
                    (C {(exit)} {(1)})
                  ]
                  spids: [-1 1844]
                )
              ]
              spids: [-1 1865]
            )
          ]
          spids: [-1 1818]
        )
      ]
      spids: [-1 1867]
    )
    (AndOr
      children: [
        (C {(test)} {(DQ (${ VSub_Name test_description))} {(KW_Bang "!") (Lit_Other "=")} {(DQ )})
        (C {(error)} {(DQ ("Test script did not set test_description."))})
      ]
      op_id: Op_DPipe
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(DQ ($ VSub_Name "$help"))} {(Lit_Other "=")} {(DQ (t))})]
          action: [
            (C {(printf)} {(SQ <"%s\\n">)} {(DQ ($ VSub_Name "$test_description"))})
            (C {(exit)} {(0)})
          ]
          spids: [-1 1907]
        )
      ]
      spids: [-1 1925]
    )
    (SimpleCommand
      words: [{(exec)}]
      redirects: [(Redir op_id:Redir_GreatAnd fd:5 arg_word:{(1)} spids:[1930])]
    )
    (SimpleCommand
      words: [{(exec)}]
      redirects: [(Redir op_id:Redir_LessAnd fd:6 arg_word:{(0)} spids:[1935])]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(DQ ($ VSub_Name "$verbose_log"))} {(Lit_Other "=")} {(DQ (t))})]
          action: [
            (SimpleCommand
              words: [{(exec)}]
              redirects: [
                (Redir
                  op_id: Redir_DGreat
                  fd: 3
                  arg_word: {(DQ ($ VSub_Name "$GIT_TEST_TEE_OUTPUT_FILE"))}
                  spids: [1957]
                )
                (Redir op_id:Redir_GreatAnd fd:4 arg_word:{(3)} spids:[1962])
              ]
            )
          ]
          spids: [-1 1952]
        )
        (if_arm
          cond: [(C {(test)} {(DQ ($ VSub_Name "$verbose"))} {(Lit_Other "=")} {(DQ (t))})]
          action: [
            (SimpleCommand
              words: [{(exec)}]
              redirects: [
                (Redir op_id:Redir_GreatAnd fd:4 arg_word:{(2)} spids:[1984])
                (Redir op_id:Redir_GreatAnd fd:3 arg_word:{(1)} spids:[1987])
              ]
            )
          ]
          spids: [1965 1979]
        )
      ]
      else_action: [
        (SimpleCommand
          words: [{(exec)}]
          redirects: [
            (Redir op_id:Redir_Great fd:4 arg_word:{(/dev/null)} spids:[1995])
            (Redir op_id:Redir_Great fd:3 arg_word:{(/dev/null)} spids:[1998])
          ]
        )
      ]
      spids: [1990 2001]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:BASH_XTRACEFD) op:Equal rhs:{(4)} spids:[2037])]
      spids: [2037]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:test_failure) op:Equal rhs:{(0)} spids:[2041])]
      spids: [2041]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:test_count) op:Equal rhs:{(0)} spids:[2044])]
      spids: [2044]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:test_fixed) op:Equal rhs:{(0)} spids:[2047])]
      spids: [2047]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:test_broken) op:Equal rhs:{(0)} spids:[2050])]
      spids: [2050]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:test_success) op:Equal rhs:{(0)} spids:[2053])]
      spids: [2053]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:test_external_has_tap) op:Equal rhs:{(0)} spids:[2057])]
      spids: [2057]
    )
    (FuncDef
      name: die
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:code)
                  op: Equal
                  rhs: {($ VSub_QMark "$?")}
                  spids: [2069]
                )
              ]
              spids: [2069]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$GIT_EXIT_OK"))})]
                  action: [(C {(exit)} {($ VSub_Name "$code")})]
                  spids: [-1 2084]
                )
              ]
              else_action: [
                (SimpleCommand
                  words: [{(echo)} {(DQ ("FATAL: Unexpected exit with code ") ($ VSub_Name "$code"))}]
                  redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(5)} spids:[2097])]
                )
                (C {(exit)} {(1)})
              ]
              spids: [2092 2111]
            )
          ]
          spids: [2066]
        )
      spids: [2061 2065]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:GIT_EXIT_OK) op:Equal rhs:{(SQ )} spids:[2116])]
      spids: [2116]
    )
    (C {(trap)} {(SQ <die>)} {(EXIT)})
    (C {(trap)} {(SQ <"exit $?">)} {(INT)})
    (C {(.)} {(DQ ($ VSub_Name "$TEST_DIRECTORY") (/test-lib-functions.sh))})
    (FuncDef
      name: test_ok_
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:test_success)
                  op: Equal
                  rhs: 
                    {
                      (ArithSubPart
                        anode: 
                          (ArithBinary
                            op_id: Arith_Plus
                            left: (ArithWord w:{($ VSub_Name "$test_success")})
                            right: (ArithWord w:{(Lit_Digits 1)})
                          )
                        spids: [2165 2172]
                      )
                    }
                  spids: [2164]
                )
              ]
              spids: [2164]
            )
            (C {(say_color)} {(DQ )} {(DQ ("ok ") ($ VSub_Name "$test_count") (" - ") ($ VSub_At "$@"))})
          ]
          spids: [2161]
        )
      spids: [2156 2160]
    )
    (FuncDef
      name: test_failure_
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:test_failure)
                  op: Equal
                  rhs: 
                    {
                      (ArithSubPart
                        anode: 
                          (ArithBinary
                            op_id: Arith_Plus
                            left: (ArithWord w:{($ VSub_Name "$test_failure")})
                            right: (ArithWord w:{(Lit_Digits 1)})
                          )
                        spids: [2199 2206]
                      )
                    }
                  spids: [2198]
                )
              ]
              spids: [2198]
            )
            (C {(say_color)} {(error)} 
              {(DQ ("not ok ") ($ VSub_Name "$test_count") (" - ") ($ VSub_Number "$1"))}
            )
            (C {(shift)})
            (Pipeline
              children: [
                (C {(printf)} {(SQ <"%s\\n">)} {(DQ ($ VSub_Star "$*"))})
                (C {(sed)} {(-e)} {(SQ <"s/^/#\t/">)})
              ]
              negated: False
            )
            (AndOr
              children: [
                (C {(test)} {(DQ ($ VSub_Name "$immediate"))} {(Lit_Other "=")} {(DQ )})
                (BraceGroup
                  children: [
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:GIT_EXIT_OK)
                              op: Equal
                              rhs: {(t)}
                              spids: [2260]
                            )
                          ]
                          spids: [2260]
                        )
                      terminator: <Op_Semi ";">
                    )
                    (Sentence child:(C {(exit)} {(1)}) terminator:<Op_Semi ";">)
                  ]
                  spids: [2258]
                )
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [2195]
        )
      spids: [2190 2194]
    )
    (FuncDef
      name: test_known_broken_ok_
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:test_fixed)
                  op: Equal
                  rhs: 
                    {
                      (ArithSubPart
                        anode: 
                          (ArithBinary
                            op_id: Arith_Plus
                            left: (ArithWord w:{($ VSub_Name "$test_fixed")})
                            right: (ArithWord w:{(Lit_Digits 1)})
                          )
                        spids: [2283 2288]
                      )
                    }
                  spids: [2282]
                )
              ]
              spids: [2282]
            )
            (C {(say_color)} {(error)} 
              {
                (DQ ("ok ") ($ VSub_Name "$test_count") (" - ") ($ VSub_At "$@") 
                  (" # TODO known breakage vanished")
                )
              }
            )
          ]
          spids: [2279]
        )
      spids: [2274 2278]
    )
    (FuncDef
      name: test_known_broken_failure_
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:test_broken)
                  op: Equal
                  rhs: 
                    {
                      (ArithSubPart
                        anode: 
                          (ArithBinary
                            op_id: Arith_Plus
                            left: (ArithWord w:{($ VSub_Name "$test_broken")})
                            right: (ArithWord w:{(Lit_Digits 1)})
                          )
                        spids: [2315 2320]
                      )
                    }
                  spids: [2314]
                )
              ]
              spids: [2314]
            )
            (C {(say_color)} {(warn)} 
              {
                (DQ ("not ok ") ($ VSub_Name "$test_count") (" - ") ($ VSub_At "$@") 
                  (" # TODO known breakage")
                )
              }
            )
          ]
          spids: [2311]
        )
      spids: [2306 2310]
    )
    (FuncDef
      name: test_debug
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(test)} {(DQ ($ VSub_Name "$debug"))} {(Lit_Other "=")} {(DQ )})
                (C {(eval)} {(DQ ($ VSub_Number "$1"))})
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [2343]
        )
      spids: [2338 2342]
    )
    (FuncDef
      name: match_pattern_list
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:arg)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [2376]
                )
              ]
              spids: [2376]
            )
            (C {(shift)})
            (AndOr
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Star "$*"))})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DAmp
            )
            (ForEach
              iter_name: pattern_
              do_arg_iter: True
              body: 
                (DoGroup
                  children: [
                    (Case
                      to_match: {(DQ ($ VSub_Name "$arg"))}
                      arms: [
                        (case_arm
                          pat_list: [{($ VSub_Name "$pattern_")}]
                          action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                          spids: [2417 2418 -1 2426]
                        )
                      ]
                      spids: [2408 2414 2426]
                    )
                  ]
                  spids: [2405 2429]
                )
              spids: [-1 -1]
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
          spids: [2373]
        )
      spids: [2368 2372]
    )
    (FuncDef
      name: match_test_selector_list
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:title)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [2447]
                )
              ]
              spids: [2447]
            )
            (C {(shift)})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:arg)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [2456]
                )
              ]
              spids: [2456]
            )
            (C {(shift)})
            (AndOr
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Number "$1"))})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
              ]
              op_id: Op_DAmp
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:OLDIFS)
                  op: Equal
                  rhs: {($ VSub_Name "$IFS")}
                  spids: [2485]
                )
              ]
              spids: [2485]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:IFS) op:Equal rhs:{(SQ <" \t,">)} spids:[2489])]
              spids: [2489]
            )
            (C {(set)} {(--)} {($ VSub_Number "$1")})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:IFS)
                  op: Equal
                  rhs: {($ VSub_Name "$OLDIFS")}
                  spids: [2502]
                )
              ]
              spids: [2502]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:include) op:Equal rhs:{(SQ )} spids:[2511])]
              spids: [2511]
            )
            (Case
              to_match: {(DQ ($ VSub_Number "$1"))}
              arms: [
                (case_arm
                  pat_list: [{(KW_Bang "!") (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:include)
                          op: Equal
                          rhs: {(t)}
                          spids: [2527]
                        )
                      ]
                      spids: [2527]
                    )
                  ]
                  spids: [2523 2525 2530 -1]
                )
              ]
              spids: [2514 2520 2533]
            )
            (ForEach
              iter_name: selector
              do_arg_iter: True
              body: 
                (DoGroup
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:orig_selector)
                          op: Equal
                          rhs: {($ VSub_Name "$selector")}
                          spids: [2545]
                        )
                      ]
                      spids: [2545]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:positive)
                          op: Equal
                          rhs: {(t)}
                          spids: [2550]
                        )
                      ]
                      spids: [2550]
                    )
                    (Case
                      to_match: {(DQ ($ VSub_Name "$selector"))}
                      arms: [
                        (case_arm
                          pat_list: [{(KW_Bang "!") (Lit_Other "*")}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:positive)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [2568]
                                )
                              ]
                              spids: [2568]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:selector)
                                  op: Equal
                                  rhs: 
                                    {
                                      (BracedVarSub
                                        token: <VSub_Name selector>
                                        suffix_op: (StringUnary op_id:VOp1_DPound arg_word:{("?")})
                                        spids: [2572 2576]
                                      )
                                    }
                                  spids: [2571]
                                )
                              ]
                              spids: [2571]
                            )
                          ]
                          spids: [2563 2565 2579 -1]
                        )
                      ]
                      spids: [2554 2560 2582]
                    )
                    (AndOr
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$selector"))})
                        (ControlFlow token:<ControlFlow_Continue continue>)
                      ]
                      op_id: Op_DAmp
                    )
                    (Case
                      to_match: {(DQ ($ VSub_Name "$selector"))}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Other "*") (-) (Lit_Other "*")}]
                          action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (SimpleCommand
                                      words: [
                                        {(expr)}
                                        {
                                          (DQ (z) 
                                            (BracedVarSub
                                              token: <VSub_Name selector>
                                              suffix_op: 
                                                (StringUnary
                                                  op_id: VOp1_DPercent
                                                  arg_word: {("-*")}
                                                )
                                              spids: [2621 2625]
                                            )
                                          )
                                        }
                                        {(Lit_Other ":")}
                                        {(DQ ("z[0-9]*[^0-9]"))}
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_Great
                                          fd: -1
                                          arg_word: {(/dev/null)}
                                          spids: [2634]
                                        )
                                      ]
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {(echo)}
                                        {
                                          (DQ ("error: ") ($ VSub_Name "$title") 
                                            (": invalid non-numeric in range")
                                          )
                                        }
                                        {(DQ ("start: '") ($ VSub_Name "$orig_selector") ("'"))}
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: -1
                                          arg_word: {(2)}
                                          spids: [2657]
                                        )
                                      ]
                                    )
                                    (C {(exit)} {(1)})
                                  ]
                                  spids: [-1 2638]
                                )
                              ]
                              spids: [-1 2666]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (SimpleCommand
                                      words: [
                                        {(expr)}
                                        {
                                          (DQ (z) 
                                            (BracedVarSub
                                              token: <VSub_Name selector>
                                              suffix_op: 
                                                (StringUnary
                                                  op_id: VOp1_Pound
                                                  arg_word: {("*-")}
                                                )
                                              spids: [2675 2679]
                                            )
                                          )
                                        }
                                        {(Lit_Other ":")}
                                        {(DQ ("z[0-9]*[^0-9]"))}
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_Great
                                          fd: -1
                                          arg_word: {(/dev/null)}
                                          spids: [2688]
                                        )
                                      ]
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {(echo)}
                                        {
                                          (DQ ("error: ") ($ VSub_Name "$title") 
                                            (": invalid non-numeric in range")
                                          )
                                        }
                                        {(DQ ("end: '") ($ VSub_Name "$orig_selector") ("'"))}
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: -1
                                          arg_word: {(2)}
                                          spids: [2711]
                                        )
                                      ]
                                    )
                                    (C {(exit)} {(1)})
                                  ]
                                  spids: [-1 2692]
                                )
                              ]
                              spids: [-1 2720]
                            )
                          ]
                          spids: [2609 2612 2723 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (SimpleCommand
                                      words: [
                                        {(expr)}
                                        {(DQ (z) ($ VSub_Name "$selector"))}
                                        {(Lit_Other ":")}
                                        {(DQ ("z[0-9]*[^0-9]"))}
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_Great
                                          fd: -1
                                          arg_word: {(/dev/null)}
                                          spids: [2745]
                                        )
                                      ]
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {(echo)}
                                        {
                                          (DQ ("error: ") ($ VSub_Name "$title") 
                                            (": invalid non-numeric in test")
                                          )
                                        }
                                        {(DQ ("selector: '") ($ VSub_Name "$orig_selector") ("'"))}
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: -1
                                          arg_word: {(2)}
                                          spids: [2768]
                                        )
                                      ]
                                    )
                                    (C {(exit)} {(1)})
                                  ]
                                  spids: [-1 2749]
                                )
                              ]
                              spids: [-1 2777]
                            )
                          ]
                          spids: [2726 2727 -1 2780]
                        )
                      ]
                      spids: [2600 2606 2780]
                    )
                    (AndOr
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$include"))})
                        (AndOr
                          children: [
                            (C {(test)} {(-z)} {(DQ ($ VSub_Name "$positive"))})
                            (ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (AndOr
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$include"))})
                        (AndOr
                          children: [
                            (C {(test)} {(-n)} {(DQ ($ VSub_Name "$positive"))})
                            (ControlFlow
                              token: <ControlFlow_Continue continue>
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (Case
                      to_match: {(DQ ($ VSub_Name "$selector"))}
                      arms: [
                        (case_arm
                          pat_list: [{(-) (Lit_Other "*")}]
                          action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (C {(test)} {($ VSub_Name "$arg")} {(-le)} 
                                      {
                                        (BracedVarSub
                                          token: <VSub_Name selector>
                                          suffix_op: (StringUnary op_id:VOp1_Pound arg_word:{(-)})
                                          spids: [2857 2861]
                                        )
                                      }
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:include)
                                          op: Equal
                                          rhs: {($ VSub_Name "$positive")}
                                          spids: [2867]
                                        )
                                      ]
                                      spids: [2867]
                                    )
                                  ]
                                  spids: [-1 2864]
                                )
                              ]
                              spids: [-1 2871]
                            )
                          ]
                          spids: [2844 2846 2874 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*") (-)}]
                          action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (C {(test)} {($ VSub_Name "$arg")} {(-ge)} 
                                      {
                                        (BracedVarSub
                                          token: <VSub_Name selector>
                                          suffix_op: (StringUnary op_id:VOp1_Percent arg_word:{(-)})
                                          spids: [2890 2894]
                                        )
                                      }
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:include)
                                          op: Equal
                                          rhs: {($ VSub_Name "$positive")}
                                          spids: [2900]
                                        )
                                      ]
                                      spids: [2900]
                                    )
                                  ]
                                  spids: [-1 2897]
                                )
                              ]
                              spids: [-1 2904]
                            )
                          ]
                          spids: [2877 2879 2907 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*") (-) (Lit_Other "*")}]
                          action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (AndOr
                                      children: [
                                        (C {(test)} 
                                          {
                                            (BracedVarSub
                                              token: <VSub_Name selector>
                                              suffix_op: 
                                                (StringUnary
                                                  op_id: VOp1_DPercent
                                                  arg_word: {("-*")}
                                                )
                                              spids: [2920 2924]
                                            )
                                          } {(-le)} {($ VSub_Name "$arg")}
                                        )
                                        (C {(test)} {($ VSub_Name "$arg")} {(-le)} 
                                          {
                                            (BracedVarSub
                                              token: <VSub_Name selector>
                                              suffix_op: 
                                                (StringUnary
                                                  op_id: VOp1_Pound
                                                  arg_word: {("*-")}
                                                )
                                              spids: [2940 2944]
                                            )
                                          }
                                        )
                                      ]
                                      op_id: Op_DAmp
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:include)
                                          op: Equal
                                          rhs: {($ VSub_Name "$positive")}
                                          spids: [2950]
                                        )
                                      ]
                                      spids: [2950]
                                    )
                                  ]
                                  spids: [-1 2947]
                                )
                              ]
                              spids: [-1 2954]
                            )
                          ]
                          spids: [2910 2913 2957 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (C {(test)} {($ VSub_Name "$arg")} {(-eq)} 
                                      {($ VSub_Name "$selector")}
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:include)
                                          op: Equal
                                          rhs: {($ VSub_Name "$positive")}
                                          spids: [2978]
                                        )
                                      ]
                                      spids: [2978]
                                    )
                                  ]
                                  spids: [-1 2975]
                                )
                              ]
                              spids: [-1 2982]
                            )
                          ]
                          spids: [2960 2961 2985 -1]
                        )
                      ]
                      spids: [2835 2841 2988]
                    )
                  ]
                  spids: [2542 2991]
                )
              spids: [-1 -1]
            )
            (C {(test)} {(-n)} {(DQ ($ VSub_Name "$include"))})
          ]
          spids: [2444]
        )
      spids: [2439 2443]
    )
    (FuncDef
      name: maybe_teardown_verbose
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$verbose_only"))})
                (ControlFlow token:<ControlFlow_Return return>)
              ]
              op_id: Op_DAmp
            )
            (SimpleCommand
              words: [{(exec)}]
              redirects: [
                (Redir op_id:Redir_Great fd:4 arg_word:{(/dev/null)} spids:[3029])
                (Redir op_id:Redir_Great fd:3 arg_word:{(/dev/null)} spids:[3032])
              ]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:verbose) op:Equal rhs:{(SQ )} spids:[3036])]
              spids: [3036]
            )
          ]
          spids: [3011]
        )
      spids: [3006 3010]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:last_verbose) op:Equal rhs:{(t)} spids:[3041])]
      spids: [3041]
    )
    (FuncDef
      name: maybe_setup_verbose
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$verbose_only"))})
                (ControlFlow token:<ControlFlow_Return return>)
              ]
              op_id: Op_DAmp
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(match_pattern_list)} {($ VSub_Name "$test_count")} 
                      {($ VSub_Name "$verbose_only")}
                    )
                  ]
                  action: [
                    (SimpleCommand
                      words: [{(exec)}]
                      redirects: [
                        (Redir
                          op_id: Redir_GreatAnd
                          fd: 4
                          arg_word: {(2)}
                          spids: [3079]
                        )
                        (Redir
                          op_id: Redir_GreatAnd
                          fd: 3
                          arg_word: {(1)}
                          spids: [3082]
                        )
                      ]
                    )
                    (AndOr
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$last_verbose"))})
                        (SimpleCommand
                          words: [{(echo)} {(DQ )}]
                          redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(3)} spids:[3118])]
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:verbose)
                          op: Equal
                          rhs: {(t)}
                          spids: [3125]
                        )
                      ]
                      spids: [3125]
                    )
                  ]
                  spids: [-1 3074]
                )
              ]
              else_action: [
                (SimpleCommand
                  words: [{(exec)}]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: 4
                      arg_word: {(/dev/null)}
                      spids: [3134]
                    )
                    (Redir
                      op_id: Redir_Great
                      fd: 3
                      arg_word: {(/dev/null)}
                      spids: [3137]
                    )
                  ]
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [(assign_pair lhs:(LhsName name:verbose) op:Equal rhs:{(SQ )} spids:[3141])]
                  spids: [3141]
                )
              ]
              spids: [3129 3144]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:last_verbose)
                  op: Equal
                  rhs: {($ VSub_Name "$verbose")}
                  spids: [3147]
                )
              ]
              spids: [3147]
            )
          ]
          spids: [3049]
        )
      spids: [3044 3048]
    )
    (FuncDef
      name: maybe_teardown_valgrind
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$GIT_VALGRIND"))})
                (ControlFlow token:<ControlFlow_Return return>)
              ]
              op_id: Op_DAmp
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:GIT_VALGRIND_ENABLED)
                  op: Equal
                  rhs: {(SQ )}
                  spids: [3174]
                )
              ]
              spids: [3174]
            )
          ]
          spids: [3158]
        )
      spids: [3153 3157]
    )
    (FuncDef
      name: maybe_setup_valgrind
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$GIT_VALGRIND"))})
                (ControlFlow token:<ControlFlow_Return return>)
              ]
              op_id: Op_DAmp
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$valgrind_only"))})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:GIT_VALGRIND_ENABLED)
                          op: Equal
                          rhs: {(t)}
                          spids: [3214]
                        )
                      ]
                      spids: [3214]
                    )
                    (ControlFlow token:<ControlFlow_Return return>)
                  ]
                  spids: [-1 3211]
                )
              ]
              spids: [-1 3221]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:GIT_VALGRIND_ENABLED)
                  op: Equal
                  rhs: {(SQ )}
                  spids: [3224]
                )
              ]
              spids: [3224]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(match_pattern_list)} {($ VSub_Name "$test_count")} 
                      {($ VSub_Name "$valgrind_only")}
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:GIT_VALGRIND_ENABLED)
                          op: Equal
                          rhs: {(t)}
                          spids: [3239]
                        )
                      ]
                      spids: [3239]
                    )
                  ]
                  spids: [-1 3236]
                )
              ]
              spids: [-1 3243]
            )
          ]
          spids: [3184]
        )
      spids: [3179 3183]
    )
    (FuncDef
      name: want_trace
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(test)} {(DQ ($ VSub_Name "$trace"))} {(Lit_Other "=")} {(t)})
                (C {(test)} {(DQ ($ VSub_Name "$verbose"))} {(Lit_Other "=")} {(t)})
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [3253]
        )
      spids: [3248 3252]
    )
    (FuncDef
      name: test_eval_inner_
      body: 
        (BraceGroup
          children: [
            (C {(eval)} {(DQ ("\n") ("\t\twant_trace && set -x\n") ("\t\t") ($ VSub_Star "$*"))})
          ]
          spids: [3298]
        )
      spids: [3293 3297]
    )
    (FuncDef
      name: test_eval_
      body: 
        (BraceGroup
          children: [
            (BraceGroup
              children: [
                (SimpleCommand
                  words: [{(test_eval_inner_)} {(DQ ($ VSub_At "$@"))}]
                  redirects: [
                    (Redir
                      op_id: Redir_Less
                      fd: -1
                      arg_word: {(/dev/null)}
                      spids: [3366]
                    )
                    (Redir
                      op_id: Redir_GreatAnd
                      fd: -1
                      arg_word: {(3)}
                      spids: [3369]
                    )
                    (Redir op_id:Redir_GreatAnd fd:2 arg_word:{(4)} spids:[3372])
                  ]
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:test_eval_ret_)
                      op: Equal
                      rhs: {($ VSub_QMark "$?")}
                      spids: [3376]
                    )
                  ]
                  spids: [3376]
                )
                (If
                  arms: [
                    (if_arm
                      cond: [(C {(want_trace)})]
                      action: [
                        (C {(set)} {(Lit_Other "+") (x)})
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (C {(test)} {(DQ ($ VSub_Name "$test_eval_ret_"))} 
                                  {(KW_Bang "!") (Lit_Other "=")} {(0)}
                                )
                              ]
                              action: [
                                (SimpleCommand
                                  words: [
                                    {(say_color)}
                                    {(error)}
                                    {
                                      (DQ ("error: last command exited with ") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\$">
                                        ) ("?=") ($ VSub_Name "$test_eval_ret_")
                                      )
                                    }
                                  ]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_GreatAnd
                                      fd: -1
                                      arg_word: {(4)}
                                      spids: [3415]
                                    )
                                  ]
                                )
                              ]
                              spids: [-1 3408]
                            )
                          ]
                          spids: [-1 3426]
                        )
                      ]
                      spids: [-1 3385]
                    )
                  ]
                  spids: [-1 3429]
                )
              ]
              redirects: [(Redir op_id:Redir_Great fd:2 arg_word:{(/dev/null)} spids:[3434])]
              spids: [3357]
            )
            (ControlFlow
              token: <ControlFlow_Return return>
              arg_word: {($ VSub_Name "$test_eval_ret_")}
            )
          ]
          spids: [3322]
        )
      spids: [3317 3321]
    )
    (FuncDef
      name: test_run_
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:test_cleanup)
                  op: Equal
                  rhs: {(Lit_Other ":")}
                  spids: [3453]
                )
              ]
              spids: [3453]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:expecting_failure)
                  op: Equal
                  rhs: {($ VSub_Number "$2")}
                  spids: [3457]
                )
              ]
              spids: [3457]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(test)} 
                          {
                            (DQ 
                              (BracedVarSub
                                token: <VSub_Name GIT_TEST_CHAIN_LINT>
                                suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(1)})
                                spids: [3467 3471]
                              )
                            )
                          } {(KW_Bang "!") (Lit_Other "=")} {(0)}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:trace_tmp)
                          op: Equal
                          rhs: {($ VSub_Name "$trace")}
                          spids: [3491]
                        )
                      ]
                      spids: [3491]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:trace)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [3495]
                        )
                      ]
                      spids: [3495]
                    )
                    (C {(test_eval_)} {(DQ ("(exit 117) && ") ($ VSub_Number "$1"))})
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(test)} {(DQ ($ VSub_QMark "$?"))} {(KW_Bang "!") (Lit_Other "=")} 
                                  {(117)}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(error)} 
                              {
                                (DQ ("bug in the test script: broken &&-chain: ") ($ VSub_Number "$1"))
                              }
                            )
                          ]
                          spids: [-1 3528]
                        )
                      ]
                      spids: [-1 3539]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:trace)
                          op: Equal
                          rhs: {($ VSub_Name "$trace_tmp")}
                          spids: [3542]
                        )
                      ]
                      spids: [3542]
                    )
                  ]
                  spids: [-1 3480]
                )
              ]
              spids: [-1 3546]
            )
            (C {(setup_malloc_check)})
            (C {(test_eval_)} {(DQ ($ VSub_Number "$1"))})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:eval_ret)
                  op: Equal
                  rhs: {($ VSub_QMark "$?")}
                  spids: [3560]
                )
              ]
              spids: [3560]
            )
            (C {(teardown_malloc_check)})
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$immediate"))})
                        (AndOr
                          children: [
                            (C {(test)} {($ VSub_Name "$eval_ret")} {(Lit_Other "=")} {(0)})
                            (AndOr
                              children: [
                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$expecting_failure"))})
                                (C {(test)} {(DQ ($ VSub_Name "$test_cleanup"))} 
                                  {(KW_Bang "!") (Lit_Other "=")} {(DQ (":"))}
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          op_id: Op_DPipe
                        )
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  action: [
                    (C {(setup_malloc_check)})
                    (C {(test_eval_)} {(DQ ($ VSub_Name "$test_cleanup"))})
                    (C {(teardown_malloc_check)})
                  ]
                  spids: [-1 3615]
                )
              ]
              spids: [-1 3631]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(test)} {(DQ ($ VSub_Name "$verbose"))} {(Lit_Other "=")} {(DQ (t))})
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$HARNESS_ACTIVE"))})
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  action: [(C {(echo)} {(DQ )})]
                  spids: [-1 3659]
                )
              ]
              spids: [-1 3668]
            )
            (ControlFlow
              token: <ControlFlow_Return return>
              arg_word: {(DQ ($ VSub_Name "$eval_ret"))}
            )
          ]
          spids: [3450]
        )
      spids: [3445 3449]
    )
    (FuncDef
      name: test_start_
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:test_count)
                  op: Equal
                  rhs: 
                    {
                      (ArithSubPart
                        anode: 
                          (ArithBinary
                            op_id: Arith_Plus
                            left: (ArithWord w:{($ VSub_Name "$test_count")})
                            right: (ArithWord w:{(Lit_Digits 1)})
                          )
                        spids: [3689 3694]
                      )
                    }
                  spids: [3688]
                )
              ]
              spids: [3688]
            )
            (C {(maybe_setup_verbose)})
            (C {(maybe_setup_valgrind)})
          ]
          spids: [3685]
        )
      spids: [3680 3684]
    )
    (FuncDef
      name: test_finish_
      body: 
        (BraceGroup
          children: [
            (SimpleCommand
              words: [{(echo)} {(DQ )}]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(3)} spids:[3715])]
            )
            (C {(maybe_teardown_valgrind)})
            (C {(maybe_teardown_verbose)})
          ]
          spids: [3710]
        )
      spids: [3705 3709]
    )
    (FuncDef
      name: test_skip
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:to_skip) op:Equal rhs:{(SQ )} spids:[3738])]
              spids: [3738]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:skipped_reason)
                  op: Equal
                  rhs: {(SQ )}
                  spids: [3741]
                )
              ]
              spids: [3741]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(match_pattern_list)} 
                      {($ VSub_Name "$this_test") (.) ($ VSub_Name "$test_count")} {($ VSub_Name "$GIT_SKIP_TESTS")}
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:to_skip)
                          op: Equal
                          rhs: {(t)}
                          spids: [3758]
                        )
                      ]
                      spids: [3758]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:skipped_reason)
                          op: Equal
                          rhs: {(DQ (GIT_SKIP_TESTS))}
                          spids: [3762]
                        )
                      ]
                      spids: [3762]
                    )
                  ]
                  spids: [-1 3755]
                )
              ]
              spids: [-1 3768]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$to_skip"))})
                        (AndOr
                          children: [
                            (C {(test)} {(-n)} {(DQ ($ VSub_Name "$test_prereq"))})
                            (Pipeline
                              children: [(C {(test_have_prereq)} {(DQ ($ VSub_Name "$test_prereq"))})]
                              negated: True
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:to_skip)
                          op: Equal
                          rhs: {(t)}
                          spids: [3806]
                        )
                      ]
                      spids: [3806]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:of_prereq)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [3811]
                        )
                      ]
                      spids: [3811]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(test)} {(DQ ($ VSub_Name "$missing_prereq"))} 
                              {(KW_Bang "!") (Lit_Other "=")} {(DQ ($ VSub_Name "$test_prereq"))}
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:of_prereq)
                                  op: Equal
                                  rhs: {(DQ (" of ") ($ VSub_Name "$test_prereq"))}
                                  spids: [3833]
                                )
                              ]
                              spids: [3833]
                            )
                          ]
                          spids: [-1 3830]
                        )
                      ]
                      spids: [-1 3840]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:skipped_reason)
                          op: Equal
                          rhs: 
                            {
                              (DQ ("missing ") ($ VSub_Name "$missing_prereq") (${ VSub_Name of_prereq))
                            }
                          spids: [3843]
                        )
                      ]
                      spids: [3843]
                    )
                  ]
                  spids: [-1 3803]
                )
              ]
              spids: [-1 3853]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$to_skip"))})
                        (AndOr
                          children: [
                            (C {(test)} {(-n)} {(DQ ($ VSub_Name "$run_list"))})
                            (Pipeline
                              children: [
                                (C {(match_test_selector_list)} {(SQ <--run>)} 
                                  {($ VSub_Name "$test_count")} {(DQ ($ VSub_Name "$run_list"))}
                                )
                              ]
                              negated: True
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:to_skip)
                          op: Equal
                          rhs: {(t)}
                          spids: [3897]
                        )
                      ]
                      spids: [3897]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:skipped_reason)
                          op: Equal
                          rhs: {(DQ (--run))}
                          spids: [3901]
                        )
                      ]
                      spids: [3901]
                    )
                  ]
                  spids: [-1 3894]
                )
              ]
              spids: [-1 3907]
            )
            (Case
              to_match: {(DQ ($ VSub_Name "$to_skip"))}
              arms: [
                (case_arm
                  pat_list: [{(t)}]
                  action: [
                    (SimpleCommand
                      words: [{(say_color)} {(skip)} {(DQ ("skipping test: ") ($ VSub_At "$@"))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(3)} spids:[3928])]
                    )
                    (C {(say_color)} {(skip)} 
                      {
                        (DQ ("ok ") ($ VSub_Name "$test_count") (" # skip ") ($ VSub_Number "$1") (" (") 
                          ($ VSub_Name "$skipped_reason") (")")
                        )
                      }
                    )
                    (C {(Lit_Other ":")} {(true)})
                  ]
                  spids: [3920 3921 3957 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [(C {(false)})]
                  spids: [3960 3961 3967 -1]
                )
              ]
              spids: [3911 3917 3970]
            )
          ]
          spids: [3735]
        )
      spids: [3730 3734]
    )
    (FuncDef
      name: test_at_end_hook_
      body: (BraceGroup children:[(C {(Lit_Other ":")})] spids:[3983])
      spids: [3978 3982]
    )
    (FuncDef
      name: test_done
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:GIT_EXIT_OK) op:Equal rhs:{(t)} spids:[3999])]
              spids: [3999]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$HARNESS_ACTIVE"))})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:test_results_dir)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$TEST_OUTPUT_DIRECTORY") (/test-results))}
                          spids: [4018]
                        )
                      ]
                      spids: [4018]
                    )
                    (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$test_results_dir"))})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:base)
                          op: Equal
                          rhs: 
                            {
                              (BracedVarSub
                                token: <VSub_Number 0>
                                suffix_op: 
                                  (StringUnary
                                    op_id: VOp1_DPound
                                    arg_word: {("*") (Lit_Slash /)}
                                  )
                                spids: [4035 4040]
                              )
                            }
                          spids: [4034]
                        )
                      ]
                      spids: [4034]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:test_results_path)
                          op: Equal
                          rhs: 
                            {
                              (DQ ($ VSub_Name "$test_results_dir") (/) 
                                (BracedVarSub
                                  token: <VSub_Name base>
                                  suffix_op: (StringUnary op_id:VOp1_Percent arg_word:{(.sh)})
                                  spids: [4047 4051]
                                ) (.counts)
                              )
                            }
                          spids: [4043]
                        )
                      ]
                      spids: [4043]
                    )
                    (SimpleCommand
                      words: [{(cat)}]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: {(DQ ($ VSub_Name "$test_results_path"))}
                          spids: [4059]
                        )
                        (HereDoc
                          op_id: Redir_DLessDash
                          fd: -1
                          body: 
                            {
                              (DQ ("total ") ($ VSub_Name "$test_count") ("\n") ("success ") 
                                ($ VSub_Name "$test_success") ("\n") ("fixed ") ($ VSub_Name "$test_fixed") ("\n") ("broken ") ($ VSub_Name "$test_broken") ("\n") 
                                ("failed ") ($ VSub_Name "$test_failure") ("\n") ("\n")
                              )
                            }
                          do_expansion: True
                          here_end: EOF
                          was_filled: True
                          spids: [4064]
                        )
                      ]
                    )
                  ]
                  spids: [-1 4015]
                )
              ]
              spids: [-1 4084]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} {(DQ ($ VSub_Name "$test_fixed"))} {(KW_Bang "!") (Lit_Other "=")} {(0)})
                  ]
                  action: [
                    (C {(say_color)} {(error)} 
                      {
                        (DQ ("# ") ($ VSub_Name "$test_fixed") 
                          (" known breakage(s) vanished; please update test(s)")
                        )
                      }
                    )
                  ]
                  spids: [-1 4102]
                )
              ]
              spids: [-1 4116]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} {(DQ ($ VSub_Name "$test_broken"))} {(KW_Bang "!") (Lit_Other "=")} {(0)})
                  ]
                  action: [
                    (C {(say_color)} {(warn)} 
                      {(DQ ("# still have ") ($ VSub_Name "$test_broken") (" known breakage(s)"))}
                    )
                  ]
                  spids: [-1 4133]
                )
              ]
              spids: [-1 4147]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(test)} {(DQ ($ VSub_Name "$test_broken"))} {(KW_Bang "!") (Lit_Other "=")} 
                          {(0)}
                        )
                        (C {(test)} {(DQ ($ VSub_Name "$test_fixed"))} {(KW_Bang "!") (Lit_Other "=")} 
                          {(0)}
                        )
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:test_remaining)
                          op: Equal
                          rhs: 
                            {
                              (ArithSubPart
                                anode: 
                                  (ArithBinary
                                    op_id: Arith_Minus
                                    left: 
                                      (ArithBinary
                                        op_id: Arith_Minus
                                        left: (ArithWord w:{($ VSub_Name "$test_count")})
                                        right: (ArithWord w:{($ VSub_Name "$test_broken")})
                                      )
                                    right: (ArithWord w:{($ VSub_Name "$test_fixed")})
                                  )
                                spids: [4181 4194]
                              )
                            }
                          spids: [4180]
                        )
                      ]
                      spids: [4180]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:msg)
                          op: Equal
                          rhs: {(DQ ("remaining ") ($ VSub_Name "$test_remaining") (" test(s)"))}
                          spids: [4197]
                        )
                      ]
                      spids: [4197]
                    )
                  ]
                  spids: [-1 4177]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:test_remaining)
                      op: Equal
                      rhs: {($ VSub_Name "$test_count")}
                      spids: [4208]
                    )
                  ]
                  spids: [4208]
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:msg)
                      op: Equal
                      rhs: {(DQ ($ VSub_Name "$test_count") (" test(s)"))}
                      spids: [4212]
                    )
                  ]
                  spids: [4212]
                )
              ]
              spids: [4205 4219]
            )
            (Case
              to_match: {(DQ ($ VSub_Name "$test_failure"))}
              arms: [
                (case_arm
                  pat_list: [{(0)}]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (AndOr
                              children: [
                                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$skip_all"))})
                                (C {(test)} {($ VSub_Name "$test_count")} {(-gt)} {(0)})
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          action: [(C {(error)} {(DQ ("Can't use skip_all after running some tests"))})]
                          spids: [-1 4260]
                        )
                      ]
                      spids: [-1 4270]
                    )
                    (AndOr
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$skip_all"))})
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:skip_all)
                              op: Equal
                              rhs: {(DQ (" # SKIP ") ($ VSub_Name "$skip_all"))}
                              spids: [4283]
                            )
                          ]
                          spids: [4283]
                        )
                      ]
                      op_id: Op_DPipe
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {($ VSub_Name "$test_external_has_tap")} {(-eq)} {(0)})]
                          action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [(C {(test)} {($ VSub_Name "$test_remaining")} {(-gt)} {(0)})]
                                  action: [
                                    (C {(say_color)} {(pass)} 
                                      {(DQ ("# passed all ") ($ VSub_Name "$msg"))}
                                    )
                                  ]
                                  spids: [-1 4316]
                                )
                              ]
                              spids: [-1 4329]
                            )
                            (C {(say)} 
                              {(DQ (1..) ($ VSub_Name "$test_count") ($ VSub_Name "$skip_all"))}
                            )
                          ]
                          spids: [-1 4302]
                        )
                      ]
                      spids: [-1 4341]
                    )
                    (AndOr
                      children: [
                        (C {(test)} {(-d)} {(DQ ($ VSub_Name "$remove_trash"))})
                        (AndOr
                          children: [
                            (C {(cd)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [(C {(dirname)} {(DQ ($ VSub_Name "$remove_trash"))})]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [4359 4365]
                                  )
                                )
                              }
                            )
                            (C {(rm)} {(-rf)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [(C {(basename)} {(DQ ($ VSub_Name "$remove_trash"))})]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [4376 4382]
                                  )
                                )
                              }
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (C {(test_at_end_hook_)})
                    (C {(exit)} {(0)})
                  ]
                  spids: [4231 4232 4395 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {($ VSub_Name "$test_external_has_tap")} {(-eq)} {(0)})]
                          action: [
                            (C {(say_color)} {(error)} 
                              {
                                (DQ ("# failed ") ($ VSub_Name "$test_failure") (" among ") 
                                  ($ VSub_Name "$msg")
                                )
                              }
                            )
                            (C {(say)} {(DQ (1..) ($ VSub_Name "$test_count"))})
                          ]
                          spids: [-1 4414]
                        )
                      ]
                      spids: [-1 4437]
                    )
                    (C {(exit)} {(1)})
                  ]
                  spids: [4399 4400 4445 -1]
                )
              ]
              spids: [4222 4228 4449]
            )
          ]
          spids: [3996]
        )
      spids: [3991 3995]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$valgrind"))})]
          action: [
            (FuncDef
              name: make_symlink
              body: 
                (BraceGroup
                  children: [
                    (AndOr
                      children: [
                        (C {(test)} {(-h)} {(DQ ($ VSub_Number "$2"))})
                        (AndOr
                          children: [
                            (C {(test)} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "=")} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [(C {(readlink)} {(DQ ($ VSub_Number "$2"))})]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [4495 4501]
                                  )
                                )
                              }
                            )
                            (BraceGroup
                              children: [
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [(C {(mkdir)} {(DQ ($ VSub_Number "$2")) (.lock)})]
                                      action: [
                                        (AndOr
                                          children: [
                                            (C {(rm)} {(-f)} {(DQ ($ VSub_Number "$2"))})
                                            (AndOr
                                              children: [
                                                (C {(ln)} {(-s)} {(DQ ($ VSub_Number "$1"))} 
                                                  {(DQ ($ VSub_Number "$2"))}
                                                )
                                                (C {(rm)} {(-r)} {(DQ ($ VSub_Number "$2")) (.lock)})
                                              ]
                                              op_id: Op_DAmp
                                            )
                                          ]
                                          op_id: Op_DAmp
                                        )
                                      ]
                                      spids: [-1 4523]
                                    )
                                  ]
                                  else_action: [
                                    (While
                                      cond: [(C {(test)} {(-d)} {(DQ ($ VSub_Number "$2")) (.lock)})]
                                      body: 
                                        (DoGroup
                                          children: [
                                            (C {(say)} 
                                              {
                                                (DQ ("Waiting for lock on ") ($ VSub_Number "$2") (.))
                                              }
                                            )
                                            (C {(sleep)} {(1)})
                                          ]
                                          spids: [4577 4594]
                                        )
                                    )
                                  ]
                                  spids: [4562 4597]
                                )
                              ]
                              spids: [4506]
                            )
                          ]
                          op_id: Op_DPipe
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  spids: [4472]
                )
              spids: [4467 4471]
            )
            (FuncDef
              name: make_valgrind_symlink
              body: 
                (BraceGroup
                  children: [
                    (Sentence
                      child: 
                        (AndOr
                          children: [
                            (C {(test)} {(-x)} {(DQ ($ VSub_Number "$1"))})
                            (AndOr
                              children: [
                                (C {(test)} {(DQ ("# "))} {(Lit_Other "=")} 
                                  {
                                    (DQ 
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (SimpleCommand
                                                words: [{(head)} {(-c)} {(2)}]
                                                redirects: [
                                                  (Redir
                                                    op_id: Redir_Less
                                                    fd: -1
                                                    arg_word: {(DQ ($ VSub_Number "$1"))}
                                                    spids: [4650]
                                                  )
                                                ]
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [4643 4654]
                                      )
                                    )
                                  }
                                )
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                )
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          op_id: Op_DPipe
                        )
                      terminator: <Op_Semi ";">
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:base)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [(C {(basename)} {(DQ ($ VSub_Number "$1"))})]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [4666 4672]
                              )
                            }
                          spids: [4665]
                        )
                      ]
                      spids: [4665]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:symlink_target)
                          op: Equal
                          rhs: {($ VSub_Name "$GIT_BUILD_DIR") (/) ($ VSub_Name "$base")}
                          spids: [4675]
                        )
                      ]
                      spids: [4675]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (AndOr
                              children: [
                                (C {(test)} {(-x)} {(DQ ($ VSub_Name "$symlink_target"))})
                                (AndOr
                                  children: [
                                    (C {(test)} {(KW_Bang "!")} {(-d)} 
                                      {(DQ ($ VSub_Name "$symlink_target"))}
                                    )
                                    (C {(test)} {(DQ ("#!"))} {(KW_Bang "!") (Lit_Other "=")} 
                                      {
                                        (DQ 
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (SimpleCommand
                                                    words: [{(head)} {(-c)} {(2)}]
                                                    redirects: [
                                                      (Redir
                                                        op_id: Redir_Less
                                                        fd: -1
                                                        arg_word: 
                                                          {(DQ ($ VSub_Name "$symlink_target"))}
                                                        spids: [4728]
                                                      )
                                                    ]
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [4721 4733]
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:symlink_target)
                                  op: Equal
                                  rhs: {(../valgrind.sh)}
                                  spids: [4740]
                                )
                              ]
                              spids: [4740]
                            )
                          ]
                          spids: [-1 4737]
                        )
                      ]
                      spids: [-1 4744]
                    )
                    (Case
                      to_match: {(DQ ($ VSub_Name "$base"))}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Other "*") (.sh)} {(Lit_Other "*") (.perl)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:symlink_target)
                                  op: Equal
                                  rhs: {(../unprocessed-script)}
                                  spids: [4764]
                                )
                              ]
                              spids: [4764]
                            )
                          ]
                          spids: [4756 4761 -1 4768]
                        )
                      ]
                      spids: [4747 4753 4768]
                    )
                    (AndOr
                      children: [
                        (C {(make_symlink)} {(DQ ($ VSub_Name "$symlink_target"))} 
                          {(DQ ($ VSub_Name "$GIT_VALGRIND") (/bin/) ($ VSub_Name "$base"))}
                        )
                        (C {(exit)})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [4612]
                )
              spids: [4607 4611]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:GIT_VALGRIND)
                  op: Equal
                  rhs: {($ VSub_Name "$TEST_DIRECTORY") (/valgrind)}
                  spids: [4800]
                )
              ]
              spids: [4800]
            )
            (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$GIT_VALGRIND")) (/bin)})
            (ForEach
              iter_name: file
              iter_words: [
                {($ VSub_Name "$GIT_BUILD_DIR") (/git) (Lit_Other "*")}
                {($ VSub_Name "$GIT_BUILD_DIR") (/t/helper/test-) (Lit_Other "*")}
              ]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [(C {(make_valgrind_symlink)} {($ VSub_Name "$file")})]
                  spids: [4830 4838]
                )
              spids: [4820 -1]
            )
            (C {(make_symlink)} {(DQ ($ VSub_Name "$GIT_BUILD_DIR")) (/mergetools)} 
              {(DQ ($ VSub_Name "$GIT_VALGRIND") (/bin/mergetools))}
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:OLDIFS)
                  op: Equal
                  rhs: {($ VSub_Name "$IFS")}
                  spids: [4858]
                )
              ]
              spids: [4858]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:IFS)
                  op: Equal
                  rhs: {(Lit_Other ":")}
                  spids: [4862]
                )
              ]
              spids: [4862]
            )
            (ForEach
              iter_name: path
              iter_words: [{($ VSub_Name "$PATH")}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (Pipeline
                      children: [
                        (SimpleCommand
                          words: [{(ls)} {(DQ ($ VSub_Name "$path")) (/git-) (Lit_Other "*")}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: 2
                              arg_word: {(/dev/null)}
                              spids: [4886]
                            )
                          ]
                        )
                        (While
                          cond: [(C {(read)} {(file)})]
                          body: 
                            (DoGroup
                              children: [(C {(make_valgrind_symlink)} {(DQ ($ VSub_Name "$file"))})]
                              spids: [4900 4910]
                            )
                        )
                      ]
                      negated: False
                    )
                  ]
                  spids: [4875 4913]
                )
              spids: [4871 -1]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:IFS)
                  op: Equal
                  rhs: {($ VSub_Name "$OLDIFS")}
                  spids: [4916]
                )
              ]
              spids: [4916]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:PATH)
                  op: Equal
                  rhs: {($ VSub_Name "$GIT_VALGRIND") (/bin) (Lit_Other ":") ($ VSub_Name "$PATH")}
                  spids: [4920]
                )
              ]
              spids: [4920]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:GIT_EXEC_PATH)
                  op: Equal
                  rhs: {($ VSub_Name "$GIT_VALGRIND") (/bin)}
                  spids: [4927]
                )
              ]
              spids: [4927]
            )
            (C {(export)} {(GIT_VALGRIND)})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:GIT_VALGRIND_MODE)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$valgrind"))}
                  spids: [4937]
                )
              ]
              spids: [4937]
            )
            (C {(export)} {(GIT_VALGRIND_MODE)})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:GIT_VALGRIND_ENABLED)
                  op: Equal
                  rhs: {(t)}
                  spids: [4948]
                )
              ]
              spids: [4948]
            )
            (AndOr
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$valgrind_only"))})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:GIT_VALGRIND_ENABLED)
                      op: Equal
                      rhs: {(SQ )}
                      spids: [4962]
                    )
                  ]
                  spids: [4962]
                )
              ]
              op_id: Op_DAmp
            )
            (C {(export)} {(GIT_VALGRIND_ENABLED)})
          ]
          spids: [-1 4464]
        )
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$GIT_TEST_INSTALLED"))})]
          action: [
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:GIT_EXEC_PATH)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {($ VSub_Name "$GIT_TEST_INSTALLED") (/git)} {(--exec-path)})
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [4983 4988]
                          )
                        }
                      spids: [4982]
                    )
                  ]
                  spids: [4982]
                )
                (C {(error)} {(DQ ("Cannot run git from ") ($ VSub_Name "$GIT_TEST_INSTALLED") (.))})
              ]
              op_id: Op_DPipe
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:PATH)
                  op: Equal
                  rhs: 
                    {($ VSub_Name "$GIT_TEST_INSTALLED") (Lit_Other ":") 
                      ($ VSub_Name "$GIT_BUILD_DIR") (Lit_Other ":") ($ VSub_Name "$PATH")
                    }
                  spids: [5002]
                )
              ]
              spids: [5002]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:GIT_EXEC_PATH)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Name GIT_TEST_EXEC_PATH>
                        suffix_op: 
                          (StringUnary
                            op_id: VTest_ColonHyphen
                            arg_word: {($ VSub_Name "$GIT_EXEC_PATH")}
                          )
                        spids: [5011 5015]
                      )
                    }
                  spids: [5010]
                )
              ]
              spids: [5010]
            )
          ]
          spids: [4969 4979]
        )
      ]
      else_action: [
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:git_bin_dir)
              op: Equal
              rhs: {(DQ ($ VSub_Name "$GIT_BUILD_DIR") (/bin-wrappers))}
              spids: [5023]
            )
          ]
          spids: [5023]
        )
        (If
          arms: [
            (if_arm
              cond: [
                (Pipeline
                  children: [(C {(test)} {(-x)} {(DQ ($ VSub_Name "$git_bin_dir") (/git))})]
                  negated: True
                )
              ]
              action: [
                (If
                  arms: [
                    (if_arm
                      cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$with_dashes"))})]
                      action: [
                        (C {(say)} 
                          {
                            (DQ ($ VSub_Name "$git_bin_dir") 
                              ("/git is not executable; using GIT_EXEC_PATH")
                            )
                          }
                        )
                      ]
                      spids: [-1 5058]
                    )
                  ]
                  spids: [-1 5069]
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:with_dashes)
                      op: Equal
                      rhs: {(t)}
                      spids: [5072]
                    )
                  ]
                  spids: [5072]
                )
              ]
              spids: [-1 5044]
            )
          ]
          spids: [-1 5076]
        )
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:PATH)
              op: Equal
              rhs: {(DQ ($ VSub_Name "$git_bin_dir") (":") ($ VSub_Name "$PATH"))}
              spids: [5079]
            )
          ]
          spids: [5079]
        )
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:GIT_EXEC_PATH)
              op: Equal
              rhs: {($ VSub_Name "$GIT_BUILD_DIR")}
              spids: [5087]
            )
          ]
          spids: [5087]
        )
        (If
          arms: [
            (if_arm
              cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$with_dashes"))})]
              action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:PATH)
                      op: Equal
                      rhs: {(DQ ($ VSub_Name "$GIT_BUILD_DIR") (":") ($ VSub_Name "$PATH"))}
                      spids: [5105]
                    )
                  ]
                  spids: [5105]
                )
              ]
              spids: [-1 5102]
            )
          ]
          spids: [-1 5113]
        )
      ]
      spids: [5017 5115]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:GIT_TEMPLATE_DIR)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$GIT_BUILD_DIR")) (/templates/blt)}
          spids: [5117]
        )
      ]
      spids: [5117]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:GIT_CONFIG_NOSYSTEM) op:Equal rhs:{(1)} spids:[5123])]
      spids: [5123]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:GIT_ATTR_NOSYSTEM) op:Equal rhs:{(1)} spids:[5126])]
      spids: [5126]
    )
    (C {(export)} {(PATH)} {(GIT_EXEC_PATH)} {(GIT_TEMPLATE_DIR)} {(GIT_CONFIG_NOSYSTEM)} 
      {(GIT_ATTR_NOSYSTEM)}
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$GIT_TEST_CMP"))})]
          action: [
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$GIT_TEST_CMP_USE_COPIED_CONTEXT"))})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:GIT_TEST_CMP)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$DIFF") (" -c"))}
                          spids: [5169]
                        )
                      ]
                      spids: [5169]
                    )
                  ]
                  spids: [-1 5166]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:GIT_TEST_CMP)
                      op: Equal
                      rhs: {(DQ ($ VSub_Name "$DIFF") (" -u"))}
                      spids: [5179]
                    )
                  ]
                  spids: [5179]
                )
              ]
              spids: [5176 5186]
            )
          ]
          spids: [-1 5152]
        )
      ]
      spids: [-1 5188]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:GITPERLLIB)
          op: Equal
          rhs: 
            {(DQ ($ VSub_Name "$GIT_BUILD_DIR")) (/perl/blib/lib) (Lit_Other ":") 
              (DQ ($ VSub_Name "$GIT_BUILD_DIR")) (/perl/blib/arch/auto/Git)
            }
          spids: [5191]
        )
      ]
      spids: [5191]
    )
    (C {(export)} {(GITPERLLIB)})
    (AndOr
      children: [
        (C {(test)} {(-d)} {(DQ ($ VSub_Name "$GIT_BUILD_DIR")) (/templates/blt)})
        (BraceGroup
          children: [(C {(error)} {(DQ ("You haven't built things yet, have you?"))})]
          spids: [5217]
        )
      ]
      op_id: Op_DPipe
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Pipeline
              children: [
                (C {(test)} {(-x)} {(DQ ($ VSub_Name "$GIT_BUILD_DIR")) (/t/helper/test-chmtime)})
              ]
              negated: True
            )
          ]
          action: [
            (SimpleCommand
              words: [{(echo)} {(SQ <"You need to build test-chmtime:">)}]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[5247])]
            )
            (SimpleCommand
              words: [
                {(echo)}
                {(SQ <"Run \"make t/helper/test-chmtime\" in the source (toplevel) directory">)}
              ]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[5257])]
            )
            (C {(exit)} {(1)})
          ]
          spids: [-1 5242]
        )
      ]
      spids: [-1 5269]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:TRASH_DIRECTORY)
          op: Equal
          rhs: 
            {
              (DQ ("trash directory.") 
                (CommandSubPart
                  command_list: 
                    (CommandList
                      children: [(C {(basename)} {(DQ ($ VSub_Number "$0"))} {(.sh)})]
                    )
                  left_token: <Left_CommandSub "$(">
                  spids: [5278 5286]
                )
              )
            }
          spids: [5275]
        )
      ]
      spids: [5275]
    )
    (AndOr
      children: [
        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$root"))})
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:TRASH_DIRECTORY)
              op: Equal
              rhs: {(DQ ($ VSub_Name "$root") (/) ($ VSub_Name "$TRASH_DIRECTORY"))}
              spids: [5299]
            )
          ]
          spids: [5299]
        )
      ]
      op_id: Op_DAmp
    )
    (Case
      to_match: {(DQ ($ VSub_Name "$TRASH_DIRECTORY"))}
      arms: [
        (case_arm pat_list:[{(/) (Lit_Other "*")}] spids:[531453165318-1])
        (case_arm
          pat_list: [{(Lit_Other "*")}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:TRASH_DIRECTORY)
                  op: Equal
                  rhs: 
                    {
                      (DQ ($ VSub_Name "$TEST_OUTPUT_DIRECTORY") (/) ($ VSub_Name "$TRASH_DIRECTORY"))
                    }
                  spids: [5327]
                )
              ]
              spids: [5327]
            )
          ]
          spids: [5324 5325 5334 -1]
        )
      ]
      spids: [5306 5312 5336]
    )
    (AndOr
      children: [
        (C {(test)} {(KW_Bang "!")} {(-z)} {(DQ ($ VSub_Name "$debug"))})
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:remove_trash)
              op: Equal
              rhs: {($ VSub_Name "$TRASH_DIRECTORY")}
              spids: [5350]
            )
          ]
          spids: [5350]
        )
      ]
      op_id: Op_DPipe
    )
    (AndOr
      children: [
        (C {(rm)} {(-fr)} {(DQ ($ VSub_Name "$TRASH_DIRECTORY"))})
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:GIT_EXIT_OK) op:Equal rhs:{(t)} spids:[5366])]
              spids: [5366]
            )
            (SimpleCommand
              words: [{(echo)} {(DQ ("FATAL: Cannot prepare test area"))}]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(5)} spids:[5372])]
            )
            (C {(exit)} {(1)})
          ]
          spids: [5363]
        )
      ]
      op_id: Op_DPipe
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:HOME)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$TRASH_DIRECTORY"))}
          spids: [5387]
        )
      ]
      spids: [5387]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:GNUPGHOME)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$HOME") (/gnupg-home-not-used))}
          spids: [5392]
        )
      ]
      spids: [5392]
    )
    (C {(export)} {(HOME)} {(GNUPGHOME)})
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$TEST_NO_CREATE_REPO"))})]
          action: [(C {(test_create_repo)} {(DQ ($ VSub_Name "$TRASH_DIRECTORY"))})]
          spids: [-1 5415]
        )
      ]
      else_action: [(C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$TRASH_DIRECTORY"))})]
      spids: [5424 5435]
    )
    (AndOr
      children: [(C {(cd)} {(-P)} {(DQ ($ VSub_Name "$TRASH_DIRECTORY"))}) (C {(exit)} {(1)})]
      op_id: Op_DPipe
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:this_test)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Number 0>
                suffix_op: (StringUnary op_id:VOp1_DPound arg_word:{("*") (Lit_Slash /)})
                spids: [5459 5464]
              )
            }
          spids: [5458]
        )
      ]
      spids: [5458]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:this_test)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name this_test>
                suffix_op: (StringUnary op_id:VOp1_DPercent arg_word:{("-*")})
                spids: [5467 5471]
              )
            }
          spids: [5466]
        )
      ]
      spids: [5466]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (C {(match_pattern_list)} {(DQ ($ VSub_Name "$this_test"))} 
              {($ VSub_Name "$GIT_SKIP_TESTS")}
            )
          ]
          action: [
            (SimpleCommand
              words: [
                {(say_color)}
                {(info)}
                {(DQ ("skipping test ") ($ VSub_Name "$this_test") (" altogether"))}
              ]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(3)} spids:[5490])]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:skip_all)
                  op: Equal
                  rhs: {(DQ ("skip all tests in ") ($ VSub_Name "$this_test"))}
                  spids: [5500]
                )
              ]
              spids: [5500]
            )
            (C {(test_done)})
          ]
          spids: [-1 5483]
        )
      ]
      spids: [-1 5509]
    )
    (FuncDef
      name: yes
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {($ VSub_Pound "$#")} {(Lit_Other "=")} {(0)})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:y) op:Equal rhs:{(y)} spids:[5537])]
                      spids: [5537]
                    )
                  ]
                  spids: [-1 5534]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:y)
                      op: Equal
                      rhs: {(DQ ($ VSub_Star "$*"))}
                      spids: [5544]
                    )
                  ]
                  spids: [5544]
                )
              ]
              spids: [5541 5550]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:i) op:Equal rhs:{(0)} spids:[5554])]
              spids: [5554]
            )
            (While
              cond: [(C {(test)} {($ VSub_Name "$i")} {(-lt)} {(99)})]
              body: 
                (DoGroup
                  children: [
                    (C {(echo)} {(DQ ($ VSub_Name "$y"))})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:i)
                          op: Equal
                          rhs: 
                            {
                              (ArithSubPart
                                anode: 
                                  (ArithBinary
                                    op_id: Arith_Plus
                                    left: (ArithWord w:{($ VSub_Name "$i")})
                                    right: (ArithWord w:{(Lit_Digits 1)})
                                  )
                                spids: [5580 5585]
                              )
                            }
                          spids: [5579]
                        )
                      ]
                      spids: [5579]
                    )
                  ]
                  spids: [5569 5588]
                )
            )
          ]
          spids: [5520]
        )
      spids: [5515 5519]
    )
    (Case
      to_match: 
        {
          (CommandSubPart
            command_list: (CommandList children:[(C {(uname)} {(-s)})])
            left_token: <Left_CommandSub "$(">
            spids: [5598 5602]
          )
        }
      arms: [
        (case_arm
          pat_list: [{(Lit_Other "*") (MINGW) (Lit_Other "*")}]
          action: [
            (FuncDef
              name: sort
              body: 
                (BraceGroup
                  children: [(C {(/usr/bin/sort)} {(DQ ($ VSub_At "$@"))})]
                  spids: [5621]
                )
              spids: [5616 5620]
            )
            (FuncDef
              name: find
              body: 
                (BraceGroup
                  children: [(C {(/usr/bin/find)} {(DQ ($ VSub_At "$@"))})]
                  spids: [5639]
                )
              spids: [5634 5638]
            )
            (FuncDef
              name: sum
              body: (BraceGroup children:[(C {(md5sum)} {(DQ ($ VSub_At "$@"))})] spids:[5657])
              spids: [5652 5656]
            )
            (FuncDef
              name: pwd
              body: (BraceGroup children:[(C {(builtin)} {(pwd)} {(-W)})] spids:[5679])
              spids: [5674 5678]
            )
            (C {(test_set_prereq)} {(MINGW)})
            (C {(test_set_prereq)} {(NATIVE_CRLF)})
            (C {(test_set_prereq)} {(SED_STRIPS_CR)})
            (C {(test_set_prereq)} {(GREP_STRIPS_CR)})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:GIT_TEST_CMP)
                  op: Equal
                  rhs: {(mingw_test_cmp)}
                  spids: [5724]
                )
              ]
              spids: [5724]
            )
          ]
          spids: [5606 5609 5728 -1]
        )
        (case_arm
          pat_list: [{(Lit_Other "*") (CYGWIN) (Lit_Other "*")}]
          action: [
            (C {(test_set_prereq)} {(POSIXPERM)})
            (C {(test_set_prereq)} {(EXECKEEPSPID)})
            (C {(test_set_prereq)} {(CYGWIN)})
            (C {(test_set_prereq)} {(SED_STRIPS_CR)})
            (C {(test_set_prereq)} {(GREP_STRIPS_CR)})
          ]
          spids: [5730 5733 5761 -1]
        )
        (case_arm
          pat_list: [{(Lit_Other "*")}]
          action: [
            (C {(test_set_prereq)} {(POSIXPERM)})
            (C {(test_set_prereq)} {(BSLASHPSPEC)})
            (C {(test_set_prereq)} {(EXECKEEPSPID)})
          ]
          spids: [5763 5764 5782 -1]
        )
      ]
      spids: [5596 5604 5784]
    )
    (AndOr
      children: [
        (Subshell
          child: 
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [(assign_pair lhs:(LhsName name:COLUMNS) op:Equal rhs:{(1)} spids:[5789])]
                  spids: [5789]
                )
                (C {(test)} {($ VSub_Name "$COLUMNS")} {(Lit_Other "=")} {(1)})
              ]
              op_id: Op_DAmp
            )
          spids: [5787 5802]
        )
        (C {(test_set_prereq)} {(COLUMNS_CAN_BE_1)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$NO_PERL"))}) (C {(test_set_prereq)} {(PERL)})]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$NO_PYTHON"))})
        (C {(test_set_prereq)} {(PYTHON)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$USE_LIBPCRE"))})
        (C {(test_set_prereq)} {(LIBPCRE)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$NO_GETTEXT"))})
        (C {(test_set_prereq)} {(GETTEXT)})
      ]
      op_id: Op_DAmp
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$GETTEXT_POISON"))})]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:GIT_GETTEXT_POISON)
                  op: Equal
                  rhs: {(YesPlease)}
                  spids: [5883]
                )
              ]
              spids: [5883]
            )
            (C {(export)} {(GIT_GETTEXT_POISON)})
            (C {(test_set_prereq)} {(GETTEXT_POISON)})
          ]
          spids: [-1 5880]
        )
      ]
      else_action: [(C {(test_set_prereq)} {(C_LOCALE_OUTPUT)})]
      spids: [5896 5903]
    )
    (FuncDef
      name: test_i18ncmp
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$GETTEXT_POISON"))})
                (C {(test_cmp)} {(DQ ($ VSub_At "$@"))})
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [5923]
        )
      spids: [5918 5922]
    )
    (FuncDef
      name: test_i18ngrep
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$GETTEXT_POISON"))})]
                  action: [(C {(Lit_Other ":")})]
                  spids: [-1 5979]
                )
                (if_arm
                  cond: [(C {(test)} {(DQ ("x!"))} {(Lit_Other "=")} {(DQ (x) ($ VSub_Number "$1"))})]
                  action: [
                    (C {(shift)})
                    (Pipeline
                      children: [(C {(grep)} {(DQ ($ VSub_At "$@"))})]
                      negated: True
                    )
                  ]
                  spids: [5988 6004]
                )
              ]
              else_action: [(C {(grep)} {(DQ ($ VSub_At "$@"))})]
              spids: [6019 6029]
            )
          ]
          spids: [5965]
        )
      spids: [5960 5964]
    )
    (C {(test_lazy_prereq)} {(PIPE)} 
      {
        (SQ <"\n"> <"\t# test whether the filesystem supports FIFOs\n"> <"\tcase $(uname -s) in\n"> 
          <"\tCYGWIN*|MINGW*)\n"> <"\t\tfalse\n"> <"\t\t;;\n"> <"\t*)\n"> <"\t\trm -f testfifo && mkfifo testfifo\n"> <"\t\t;;\n"> 
          <"\tesac\n">
        )
      }
    )
    (C {(test_lazy_prereq)} {(SYMLINKS)} 
      {
        (SQ <"\n"> <"\t# test whether the filesystem supports symbolic links\n"> 
          <"\tln -s x y && test -h y\n">
        )
      }
    )
    (C {(test_lazy_prereq)} {(FILEMODE)} 
      {(SQ <"\n"> <"\ttest \"$(git config --bool core.filemode)\" = true\n">)}
    )
    (C {(test_lazy_prereq)} {(CASE_INSENSITIVE_FS)} 
      {
        (SQ <"\n"> <"\techo good >CamelCase &&\n"> <"\techo bad >camelcase &&\n"> 
          <"\ttest \"$(cat CamelCase)\" != good\n">
        )
      }
    )
    (C {(test_lazy_prereq)} {(UTF8_NFD_TO_NFC)} 
      {
        (SQ <"\n"> <"\t# check whether FS converts nfd unicode to nfc\n"> 
          <"\tauml=$(printf \"\\303\\244\")\n"> <"\taumlcdiar=$(printf \"\\141\\314\\210\")\n"> <"\t>\"$auml\" &&\n"> <"\tcase \"$(echo *)\" in\n"> 
          <"\t\"$aumlcdiar\")\n"> <"\t\ttrue ;;\n"> <"\t*)\n"> <"\t\tfalse ;;\n"> <"\tesac\n">
        )
      }
    )
    (C {(test_lazy_prereq)} {(AUTOIDENT)} 
      {
        (SQ <"\n"> <"\tsane_unset GIT_AUTHOR_NAME &&\n"> <"\tsane_unset GIT_AUTHOR_EMAIL &&\n"> 
          <"\tgit var GIT_AUTHOR_IDENT\n">
        )
      }
    )
    (C {(test_lazy_prereq)} {(EXPENSIVE)} {(SQ <"\n"> <"\ttest -n \"$GIT_TEST_LONG\"\n">)})
    (C {(test_lazy_prereq)} {(USR_BIN_TIME)} {(SQ <"\n"> <"\ttest -x /usr/bin/time\n">)})
    (C {(test_lazy_prereq)} {(NOT_ROOT)} {(SQ <"\n"> <"\tuid=$(id -u) &&\n"> <"\ttest \"$uid\" != 0\n">)})
    (C {(test_lazy_prereq)} {(JGIT)} {(SQ <"\n"> <"\ttype jgit\n">)})
    (C {(test_lazy_prereq)} {(SANITY)} 
      {
        (SQ <"\n"> <"\tmkdir SANETESTD.1 SANETESTD.2 &&\n"> <"\n"> 
          <"\tchmod +w SANETESTD.1 SANETESTD.2 &&\n"> <"\t>SANETESTD.1/x 2>SANETESTD.2/x &&\n"> <"\tchmod -w SANETESTD.1 &&\n"> 
          <"\tchmod -r SANETESTD.1/x &&\n"> <"\tchmod -rx SANETESTD.2 ||\n"> <"\terror \"bug in test sript: cannot prepare SANETESTD\"\n"> <"\n"> 
          <"\t! test -r SANETESTD.1/x &&\n"> <"\t! rm SANETESTD.1/x && ! test -f SANETESTD.2/x\n"> <"\tstatus=$?\n"> <"\n"> 
          <"\tchmod +rwx SANETESTD.1 SANETESTD.2 &&\n"> <"\trm -rf SANETESTD.1 SANETESTD.2 ||\n"> <"\terror \"bug in test sript: cannot clean SANETESTD\"\n"> 
          <"\treturn $status\n">
        )
      }
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:GIT_UNZIP)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name GIT_UNZIP>
                suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(unzip)})
                spids: [6215 6219]
              )
            }
          spids: [6214]
        )
      ]
      spids: [6214]
    )
    (C {(test_lazy_prereq)} {(UNZIP)} {(SQ <"\n"> <"\t\"$GIT_UNZIP\" -v\n"> <"\ttest $? -ne 127\n">)})
    (FuncDef
      name: run_with_limited_cmdline
      body: 
        (BraceGroup
          children: [
            (Subshell
              child: 
                (AndOr
                  children: [(C {(ulimit)} {(-s)} {(128)}) (C {(DQ ($ VSub_At "$@"))})]
                  op_id: Op_DAmp
                )
              spids: [6240 6252]
            )
          ]
          spids: [6237]
        )
      spids: [6232 6236]
    )
    (C {(test_lazy_prereq)} {(CMDLINE_LIMIT)} {(SQ <"run_with_limited_cmdline true">)})
    (FuncDef
      name: build_option
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [
                (C {(git)} {(version)} {(--build-options)})
                (C {(sed)} {(-ne)} {(DQ ("s/^") ($ VSub_Number "$1") (": //p"))})
              ]
              negated: False
            )
          ]
          spids: [6271]
        )
      spids: [6266 6270]
    )
    (C {(test_lazy_prereq)} {(LONG_IS_64BIT)} 
      {(SQ <"\n"> <"\ttest 8 -le \"$(build_option sizeof-long)\"\n">)}
    )
  ]
)