(CommandList
  children: [
    (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: [72 75 82 -1]
        )
        (case_arm
          pat_list: [
            {(Lit_Other "*") (SQ <" --tee ">) (Lit_Other "*")}
            {(Lit_Other "*") (SQ <" --va">) (Lit_Other "*")}
          ]
          action: [
            (C {(mkdir)} {(-p)} {(test-results)})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:BASE)
                  op: Equal
                  rhs: 
                    {(test-results/) 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(basename)} {(DQ ($ VSub_Number "$0"))} {(.sh)})]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [107 115]
                      )
                    }
                  spids: [105]
                )
              ]
              spids: [105]
            )
            (Pipeline
              children: [
                (Subshell
                  child: 
                    (CommandList
                      children: [
                        (Sentence
                          child: 
                            (SimpleCommand
                              words: [
                                {
                                  (BracedVarSub
                                    token: <VSub_Name SHELL>
                                    suffix_op: (StringUnary op_id:VTest_Hyphen arg_word:{(sh)})
                                    spids: [122 126]
                                  )
                                }
                                {(DQ ($ VSub_Number "$0"))}
                                {(DQ ($ VSub_At "$@"))}
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 2
                                  arg_word: {(1)}
                                  spids: [136]
                                )
                              ]
                              more_env: [
                                (env_pair
                                  name: GIT_TEST_TEE_STARTED
                                  val: {(KW_Done done)}
                                  spids: [119]
                                )
                              ]
                            )
                          terminator: <Op_Semi ";">
                        )
                        (SimpleCommand
                          words: [{(echo)} {($ VSub_QMark "$?")}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: -1
                              arg_word: {($ VSub_Name "$BASE") (.exit)}
                              spids: [145]
                            )
                          ]
                        )
                      ]
                    )
                  spids: [118 149]
                )
                (C {(tee)} {($ VSub_Name "$BASE") (.out)})
              ]
              negated: False
            )
            (C {(test)} 
              {
                (DQ 
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [(C {(cat)} {($ VSub_Name "$BASE") (.exit)})]
                      )
                    left_token: <Left_CommandSub "$(">
                    spids: [162 167]
                  )
                )
              } {(Lit_Other "=")} {(0)}
            )
            (C {(exit)})
          ]
          spids: [84 95 178 -1]
        )
      ]
      spids: [61 70 180]
    )
    (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: [184 186]
              ) (/..)
            }
          spids: [183]
        )
      ]
      spids: [183]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:TEST_OUTPUT_DIRECTORY)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: (CommandList children:[(C {(pwd)})])
                left_token: <Left_CommandSub "$(">
                spids: [190 192]
              )
            }
          spids: [189]
        )
      ]
      spids: [189]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$GIT_TEST_INSTALLED"))})
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:perf_results_prefix)
                  op: Equal
                  rhs: {(SQ )}
                  spids: [208]
                )
              ]
              spids: [208]
            )
          ]
          spids: [-1 205]
        )
      ]
      else_action: [
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:perf_results_prefix)
              op: Equal
              rhs: 
                {
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [
                          (Pipeline
                            children: [
                              (C {(printf)} {(DQ ("%s"))} 
                                {
                                  (DQ 
                                    (BracedVarSub
                                      token: <VSub_Name GIT_TEST_INSTALLED>
                                      suffix_op: 
                                        (StringUnary
                                          op_id: VOp1_Percent
                                          arg_word: {(Lit_Slash /) (bin-wrappers)}
                                        )
                                      spids: [222 227]
                                    )
                                  )
                                }
                              )
                              (C {(tr)} {(-c)} {(DQ ("[a-zA-Z0-9]"))} {(DQ ("[_*]"))})
                            ]
                            negated: False
                          )
                        ]
                      )
                    left_token: <Left_CommandSub "$(">
                    spids: [214 243]
                  ) (DQ (.))
                }
              spids: [213]
            )
          ]
          spids: [213]
        )
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:GIT_TEST_INSTALLED)
              op: Equal
              rhs: 
                {
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [
                          (AndOr
                            children: [(C {(cd)} {(DQ ($ VSub_Name "$GIT_TEST_INSTALLED"))}) (C {(pwd)})]
                            op_id: Op_DAmp
                          )
                        ]
                      )
                    left_token: <Left_CommandSub "$(">
                    spids: [254 264]
                  )
                }
              spids: [253]
            )
          ]
          spids: [253]
        )
      ]
      spids: [210 266]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:TEST_NO_CREATE_REPO) op:Equal rhs:{(t)} spids:[269])]
      spids: [269]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:TEST_NO_MALLOC_CHECK) op:Equal rhs:{(t)} spids:[272])]
      spids: [272]
    )
    (C {(.)} {(../test-lib.sh)})
    (C {(export)} {(TEST_DIRECTORY)} {(TRASH_DIRECTORY)} {(GIT_BUILD_DIR)} {(GIT_TEST_CMP)})
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:MODERN_GIT)
          op: Equal
          rhs: {($ VSub_Name "$GIT_BUILD_DIR") (/bin-wrappers/git)}
          spids: [298]
        )
      ]
      spids: [298]
    )
    (C {(export)} {(MODERN_GIT)})
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:perf_results_dir)
          op: Equal
          rhs: {($ VSub_Name "$TEST_OUTPUT_DIRECTORY") (/test-results)}
          spids: [307]
        )
      ]
      spids: [307]
    )
    (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$perf_results_dir"))})
    (C {(rm)} {(-f)} 
      {(DQ ($ VSub_Name "$perf_results_dir")) (/) 
        (CommandSubPart
          command_list: (CommandList children:[(C {(basename)} {(DQ ($ VSub_Number "$0"))} {(.sh)})])
          left_token: <Left_CommandSub "$(">
          spids: [327 335]
        ) (.subtests)
      }
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$GIT_PERF_REPEAT_COUNT"))})
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:GIT_PERF_REPEAT_COUNT)
                  op: Equal
                  rhs: {(3)}
                  spids: [353]
                )
              ]
              spids: [353]
            )
          ]
          spids: [-1 350]
        )
      ]
      spids: [-1 356]
    )
    (FuncDef
      name: die_if_build_dir_not_repo
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (Pipeline
                          children: [
                            (Subshell
                              child: 
                                (AndOr
                                  children: [
                                    (C {(cd)} {(DQ ($ VSub_Name "$TEST_DIRECTORY") (/..))})
                                    (SimpleCommand
                                      words: [{(git)} {(rev-parse)} {(--build-dir)}]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_Great
                                          fd: -1
                                          arg_word: {(/dev/null)}
                                          spids: [388]
                                        )
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 2
                                          arg_word: {(1)}
                                          spids: [391]
                                        )
                                      ]
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              spids: [370 394]
                            )
                          ]
                          negated: True
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(error)} 
                      {
                        (DQ ("No ") ($ VSub_Number "$1") 
                          (" defined, and your build directory is not a repo")
                        )
                      }
                    )
                  ]
                  spids: [-1 397]
                )
              ]
              spids: [-1 409]
            )
          ]
          spids: [363]
        )
      spids: [358 362]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$GIT_PERF_REPO"))})
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (C {(die_if_build_dir_not_repo)} {(SQ <"$GIT_PERF_REPO">)})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:GIT_PERF_REPO)
                  op: Equal
                  rhs: {($ VSub_Name "$TEST_DIRECTORY") (/..)}
                  spids: [435]
                )
              ]
              spids: [435]
            )
          ]
          spids: [-1 425]
        )
      ]
      spids: [-1 439]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$GIT_PERF_LARGE_REPO"))})
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (C {(die_if_build_dir_not_repo)} {(SQ <"$GIT_PERF_LARGE_REPO">)})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:GIT_PERF_LARGE_REPO)
                  op: Equal
                  rhs: {($ VSub_Name "$TEST_DIRECTORY") (/..)}
                  spids: [462]
                )
              ]
              spids: [462]
            )
          ]
          spids: [-1 452]
        )
      ]
      spids: [-1 466]
    )
    (FuncDef
      name: test_perf_create_repo_from
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(test)} {(DQ ($ VSub_Pound "$#"))} {(Lit_Other "=")} {(2)})
                (C {(error)} {(DQ ("bug in the test script: not 2 parameters to test-create-repo"))})
              ]
              op_id: Op_DPipe
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:repo)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [497]
                )
              ]
              spids: [497]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:source)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$2"))}
                  spids: [503]
                )
              ]
              spids: [503]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:source_git)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [
                                (C {(git)} {(-C)} {(DQ ($ VSub_Name "$source"))} {(rev-parse)} 
                                  {(--git-dir)}
                                )
                              ]
                            )
                          left_token: <Left_CommandSub "$(">
                          spids: [511 523]
                        )
                      )
                    }
                  spids: [509]
                )
              ]
              spids: [509]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:objects_dir)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [
                                (C {(DQ ($ VSub_Name "$MODERN_GIT"))} {(-C)} 
                                  {(DQ ($ VSub_Name "$source"))} {(rev-parse)} {(--git-path)} {(objects)}
                                )
                              ]
                            )
                          left_token: <Left_CommandSub "$(">
                          spids: [529 545]
                        )
                      )
                    }
                  spids: [527]
                )
              ]
              spids: [527]
            )
            (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$repo") (/.git))})
            (AndOr
              children: [
                (Subshell
                  child: 
                    (AndOr
                      children: [
                        (C {(cd)} {(DQ ($ VSub_Name "$source"))})
                        (AndOr
                          children: [
                            (BraceGroup
                              children: [
                                (Sentence
                                  child: 
                                    (AndOr
                                      children: [
                                        (SimpleCommand
                                          words: [
                                            {(cp)}
                                            {(-Rl)}
                                            {(DQ ($ VSub_Name "$objects_dir"))}
                                            {(DQ ($ VSub_Name "$repo") (/.git/))}
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_Great
                                              fd: 2
                                              arg_word: {(/dev/null)}
                                              spids: [586]
                                            )
                                          ]
                                        )
                                        (C {(cp)} {(-R)} {(DQ ($ VSub_Name "$objects_dir"))} 
                                          {(DQ ($ VSub_Name "$repo") (/.git/))}
                                        )
                                      ]
                                      op_id: Op_DPipe
                                    )
                                  terminator: <Op_Semi ";">
                                )
                              ]
                              spids: [571]
                            )
                            (ForEach
                              iter_name: stuff
                              iter_words: [{(DQ ($ VSub_Name "$source_git")) (/) (Lit_Other "*")}]
                              do_arg_iter: False
                              body: 
                                (DoGroup
                                  children: [
                                    (Case
                                      to_match: {(DQ ($ VSub_Name "$stuff"))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") (/objects)}
                                            {(Lit_Other "*") (/hooks)}
                                            {(Lit_Other "*") (/config)}
                                            {(Lit_Other "*") (/commondir)}
                                          ]
                                          spids: [636 647 650 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (AndOr
                                              children: [
                                                (C {(cp)} {(-R)} {(DQ ($ VSub_Name "$stuff"))} 
                                                  {(DQ ($ VSub_Name "$repo") (/.git/))}
                                                )
                                                (C {(exit)} {(1)})
                                              ]
                                              op_id: Op_DPipe
                                            )
                                          ]
                                          spids: [653 654 677 -1]
                                        )
                                      ]
                                      spids: [627 633 680]
                                    )
                                  ]
                                  spids: [624 683]
                                )
                              spids: [616 622]
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  spids: [559 686]
                )
                (AndOr
                  children: [
                    (Subshell
                      child: 
                        (AndOr
                          children: [
                            (C {(cd)} {(DQ ($ VSub_Name "$repo"))})
                            (AndOr
                              children: [
                                (C {(git)} {(init)} {(-q)})
                                (AndOr
                                  children: [
                                    (BraceGroup
                                      children: [
                                        (AndOr
                                          children: [
                                            (C {(test_have_prereq)} {(SYMLINKS)})
                                            (C {(git)} {(config)} {(core.symlinks)} {(false)})
                                          ]
                                          op_id: Op_DPipe
                                        )
                                      ]
                                      spids: [711]
                                    )
                                    (SimpleCommand
                                      words: [{(mv)} {(.git/hooks)} {(.git/hooks-disabled)}]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_Great
                                          fd: 2
                                          arg_word: {(/dev/null)}
                                          spids: [741]
                                        )
                                      ]
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      spids: [691 745]
                    )
                    (C {(error)} 
                      {
                        (DQ ("failed to copy repository '") ($ VSub_Name "$source") ("' to '") 
                          ($ VSub_Name "$repo") ("'")
                        )
                      }
                    )
                  ]
                  op_id: Op_DPipe
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [474]
        )
      spids: [469 473]
    )
    (FuncDef
      name: test_perf_default_repo
      body: 
        (BraceGroup
          children: [
            (C {(test_perf_create_repo_from)} 
              {
                (DQ 
                  (BracedVarSub
                    token: <VSub_Number 1>
                    suffix_op: 
                      (StringUnary
                        op_id: VTest_ColonHyphen
                        arg_word: {($ VSub_Name "$TRASH_DIRECTORY")}
                      )
                    spids: [776 780]
                  )
                )
              } {(DQ ($ VSub_Name "$GIT_PERF_REPO"))}
            )
          ]
          spids: [770]
        )
      spids: [765 769]
    )
    (FuncDef
      name: test_perf_large_repo
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(test)} {(DQ ($ VSub_Name "$GIT_PERF_LARGE_REPO"))} {(Lit_Other "=")} 
                          {(DQ ($ VSub_Name "$GIT_BUILD_DIR"))}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (SimpleCommand
                      words: [
                        {(echo)}
                        {
                          (DQ ("warning: ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                            ("GIT_PERF_LARGE_REPO is ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (GIT_BUILD_DIR.)
                          )
                        }
                      ]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[825])]
                    )
                    (SimpleCommand
                      words: [
                        {(echo)}
                        {(DQ ("warning: This will work, but may not be a sufficiently large repo"))}
                      ]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[835])]
                    )
                    (SimpleCommand
                      words: [{(echo)} {(DQ ("warning: for representative measurements."))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[845])]
                    )
                  ]
                  spids: [-1 812]
                )
              ]
              spids: [-1 849]
            )
            (C {(test_perf_create_repo_from)} 
              {
                (DQ 
                  (BracedVarSub
                    token: <VSub_Number 1>
                    suffix_op: 
                      (StringUnary
                        op_id: VTest_ColonHyphen
                        arg_word: {($ VSub_Name "$TRASH_DIRECTORY")}
                      )
                    spids: [855 859]
                  )
                )
              } {(DQ ($ VSub_Name "$GIT_PERF_LARGE_REPO"))}
            )
          ]
          spids: [794]
        )
      spids: [789 793]
    )
    (FuncDef
      name: test_checkout_worktree
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(git)} {(checkout-index)} {(-u)} {(-a)})
                (C {(error)} {(DQ ("git checkout-index failed"))})
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [873]
        )
      spids: [868 872]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:immediate) op:Equal rhs:{(t)} spids:[899])]
      spids: [899]
    )
    (Case
      to_match: 
        {
          (DQ 
            (CommandSubPart
              command_list: (CommandList children:[(C {(uname)} {(-s)})])
              left_token: <Left_CommandSub "$(">
              spids: [909 913]
            )
          )
        }
      arms: [
        (case_arm
          pat_list: [{(Darwin)}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:GTIME)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (BracedVarSub
                          token: <VSub_Name GTIME>
                          suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(gtime)})
                          spids: [923 927]
                        )
                      )
                    }
                  spids: [921]
                )
              ]
              spids: [921]
            )
          ]
          spids: [918 919 929 -1]
        )
      ]
      spids: [906 916 931]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:GTIME)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name GTIME>
                  suffix_op: 
                    (StringUnary
                      op_id: VTest_ColonHyphen
                      arg_word: {(Lit_Slash /) (usr) (Lit_Slash /) (bin) (Lit_Slash /) (time)}
                    )
                  spids: [935 944]
                )
              )
            }
          spids: [933]
        )
      ]
      spids: [933]
    )
    (FuncDef
      name: test_run_perf_
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:test_cleanup)
                  op: Equal
                  rhs: {(Lit_Other ":")}
                  spids: [956]
                )
              ]
              spids: [956]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:test_export_)
                  op: Equal
                  rhs: {(DQ (test_cleanup))}
                  spids: [960]
                )
              ]
              spids: [960]
            )
            (C {(export)} {(test_cleanup)} {(test_export_)})
            (SimpleCommand
              words: [
                {(DQ ($ VSub_Name "$GTIME"))}
                {(-f)}
                {(DQ ("%E %U %S"))}
                {(-o)}
                {(test_time.) ($ VSub_Name "$i")}
                {(DQ ($ VSub_Name "$SHELL"))}
                {(-c)}
                {(SQ <"\n"> <". ">) (DQ ($ VSub_Name "$TEST_DIRECTORY")) (/test-lib-functions.sh) 
                  (SQ <"\n"> <"test_export () {\n"> <"\t[ $# != 0 ] || return 0\n"> 
                    <"\ttest_export_=\"$test_export_\\\\|$1\"\n"> <"\tshift\n"> <"\ttest_export \"$@\"\n"> <"}\n">
                  ) (DQ ($ VSub_Number "$1")) (SQ <"\n"> <"ret=$?\n"> <"set | sed -n \"s">) 
                  (DQ ("/'/'") (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) 
                    (EscapedLiteralPart token:<Lit_EscapedChar "\\\\">) ("''/g")
                  ) (SQ <";s/^\\\\($test_export_\\\\)/export ">) (DQ ("'&'")) (SQ <"/p\" >test_vars\n"> <"exit $ret">)
                }
              ]
              redirects: [
                (Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(3)} spids:[1036])
                (Redir op_id:Redir_GreatAnd fd:2 arg_word:{(4)} spids:[1039])
              ]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:eval_ret)
                  op: Equal
                  rhs: {($ VSub_QMark "$?")}
                  spids: [1043]
                )
              ]
              spids: [1043]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(test)} {($ VSub_Name "$eval_ret")} {(Lit_Other "=")} {(0)})
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$expecting_failure"))})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  action: [
                    (C {(test_eval_)} {(DQ ($ VSub_Name "$test_cleanup"))})
                    (AndOr
                      children: [
                        (C {(.)} {(./test_vars)})
                        (C {(error)} {(DQ ("failed to load updated environment"))})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [-1 1069]
                )
              ]
              spids: [-1 1092]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (AndOr
                          children: [
                            (C {(test)} {(DQ ($ VSub_Name "$verbose"))} {(Lit_Other "=")} {(DQ (t))})
                            (C {(test)} {(-n)} {(DQ ($ VSub_Name "$HARNESS_ACTIVE"))})
                          ]
                          op_id: Op_DAmp
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [(C {(echo)} {(DQ )})]
                  spids: [-1 1120]
                )
              ]
              spids: [-1 1129]
            )
            (ControlFlow
              token: <ControlFlow_Return return>
              arg_word: {(DQ ($ VSub_Name "$eval_ret"))}
            )
          ]
          spids: [953]
        )
      spids: [948 952]
    )
    (FuncDef
      name: test_perf
      body: 
        (BraceGroup
          children: [
            (C {(test_start_)})
            (AndOr
              children: [
                (C {(test)} {(DQ ($ VSub_Pound "$#"))} {(Lit_Other "=")} {(3)})
                (AndOr
                  children: [
                    (BraceGroup
                      children: [
                        (Sentence
                          child: 
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:test_prereq)
                                  op: Equal
                                  rhs: {($ VSub_Number "$1")}
                                  spids: [1167]
                                )
                              ]
                              spids: [1167]
                            )
                          terminator: <Op_Semi ";">
                        )
                        (Sentence
                          child: (C {(shift)})
                          terminator: <Op_Semi ";">
                        )
                      ]
                      spids: [1165]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:test_prereq)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [1178]
                        )
                      ]
                      spids: [1178]
                    )
                  ]
                  op_id: Op_DPipe
                )
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (C {(test)} {(DQ ($ VSub_Pound "$#"))} {(Lit_Other "=")} {(2)})
                (C {(error)} 
                  {(DQ ("bug in the test script: not 2 or 3 parameters to test-expect-success"))}
                )
              ]
              op_id: Op_DPipe
            )
            (C {(export)} {(test_prereq)})
            (If
              arms: [
                (if_arm
                  cond: [(Pipeline children:[(C {(test_skip)} {(DQ ($ VSub_At "$@"))})] negated:True)]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:base)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [(C {(basename)} {(DQ ($ VSub_Number "$0"))} {(.sh)})]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [1221 1229]
                              )
                            }
                          spids: [1220]
                        )
                      ]
                      spids: [1220]
                    )
                    (SimpleCommand
                      words: [{(echo)} {(DQ ($ VSub_Name "$test_count"))}]
                      redirects: [
                        (Redir
                          op_id: Redir_DGreat
                          fd: -1
                          arg_word: 
                            {(DQ ($ VSub_Name "$perf_results_dir")) (/) ($ VSub_Name "$base") 
                              (.subtests)
                            }
                          spids: [1238]
                        )
                      ]
                    )
                    (SimpleCommand
                      words: [{(echo)} {(DQ ($ VSub_Number "$1"))}]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: 
                            {(DQ ($ VSub_Name "$perf_results_dir")) (/) ($ VSub_Name "$base") (.) 
                              ($ VSub_Name "$test_count") (.descr)
                            }
                          spids: [1253]
                        )
                      ]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$verbose"))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(printf)} {(DQ ("%s"))} 
                              {
                                (DQ ("perf ") ($ VSub_Name "$test_count") (" - ") ($ VSub_Number "$1") 
                                  (":")
                                )
                              }
                            )
                          ]
                          spids: [-1 1275]
                        )
                      ]
                      else_action: [
                        (C {(echo)} 
                          {
                            (DQ ("perf ") ($ VSub_Name "$test_count") (" - ") ($ VSub_Number "$1") (":"))
                          }
                        )
                      ]
                      spids: [1293 1307]
                    )
                    (ForEach
                      iter_name: i
                      iter_words: [
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(test_seq)} {(1)} {($ VSub_Name "$GIT_PERF_REPEAT_COUNT")})
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [1316 1322]
                          )
                        }
                      ]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (SimpleCommand
                              words: [{(say)} {(DQ ("running: ") ($ VSub_Number "$2"))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: -1
                                  arg_word: {(3)}
                                  spids: [1330]
                                )
                              ]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [(C {(test_run_perf_)} {(DQ ($ VSub_Number "$2"))})]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$verbose"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (C {(printf)} {(DQ (" %s"))} {(DQ ($ VSub_Name "$i"))})
                                          ]
                                          spids: [-1 1362]
                                        )
                                      ]
                                      else_action: [
                                        (C {(echo)} 
                                          {
                                            (DQ ("* timing run ") ($ VSub_Name "$i") (/) 
                                              ($ VSub_Name "$GIT_PERF_REPEAT_COUNT") (":")
                                            )
                                          }
                                        )
                                      ]
                                      spids: [1376 1390]
                                    )
                                  ]
                                  spids: [-1 1348]
                                )
                              ]
                              else_action: [
                                (AndOr
                                  children: [
                                    (C {(test)} {(-z)} {(DQ ($ VSub_Name "$verbose"))})
                                    (C {(echo)})
                                  ]
                                  op_id: Op_DAmp
                                )
                                (C {(test_failure_)} {(DQ ($ VSub_At "$@"))})
                                (ControlFlow
                                  token: <ControlFlow_Break break>
                                )
                              ]
                              spids: [1393 1419]
                            )
                          ]
                          spids: [1325 1422]
                        )
                      spids: [1315 1323]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$verbose"))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [(C {(echo)} {(DQ (" ok"))})]
                          spids: [-1 1436]
                        )
                      ]
                      else_action: [(C {(test_ok_)} {(DQ ($ VSub_Number "$1"))})]
                      spids: [1446 1456]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:base)
                          op: Equal
                          rhs: 
                            {(DQ ($ VSub_Name "$perf_results_dir")) (/) 
                              (DQ ($ VSub_Name "$perf_results_prefix") 
                                (CommandSubPart
                                  command_list: 
                                    (CommandList
                                      children: [(C {(basename)} {(DQ ($ VSub_Number "$0"))} {(.sh)})]
                                    )
                                  left_token: <Left_CommandSub "$(">
                                  spids: [1466 1474]
                                )
                              ) (.) (DQ ($ VSub_Name "$test_count"))
                            }
                          spids: [1459]
                        )
                      ]
                      spids: [1459]
                    )
                    (SimpleCommand
                      words: [
                        {(DQ ($ VSub_Name "$TEST_DIRECTORY")) (/perf/min_time.perl)}
                        {(test_time.) (Lit_Other "*")}
                      ]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: {(DQ ($ VSub_Name "$base")) (.times)}
                          spids: [1490]
                        )
                      ]
                    )
                  ]
                  spids: [-1 1217]
                )
              ]
              spids: [-1 1497]
            )
            (C {(test_finish_)})
          ]
          spids: [1147]
        )
      spids: [1142 1146]
    )
    (FuncDef
      name: test_at_end_hook_
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$GIT_PERF_AGGREGATING_LATER"))})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Subshell
                      child: 
                        (AndOr
                          children: [
                            (C {(cd)} {(DQ ($ VSub_Name "$TEST_DIRECTORY")) (/perf)})
                            (C {(./aggregate.perl)} 
                              {
                                (CommandSubPart
                                  command_list: 
                                    (CommandList
                                      children: [(C {(basename)} {(DQ ($ VSub_Number "$0"))})]
                                    )
                                  left_token: <Left_CommandSub "$(">
                                  spids: [1546 1552]
                                )
                              }
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      spids: [1533 1554]
                    )
                  ]
                  spids: [-1 1530]
                )
              ]
              spids: [-1 1557]
            )
          ]
          spids: [1516]
        )
      spids: [1511 1515]
    )
    (FuncDef
      name: test_export
      body: (BraceGroup children:[(C {(export)} {(DQ ($ VSub_At "$@"))})] spids:[1567])
      spids: [1562 1566]
    )
  ]
)