(command.CommandList
  children: [
    (command.Case
      to_match: 
        {(DQ ($ Id.VSub_DollarName '$GIT_TEST_TEE_STARTED') <', '> ($ Id.VSub_Star '$*') <' '>)}
      arms: [
        (case_arm
          pat_list: [{<Id.KW_Done done> <Id.Lit_Comma ','> <Id.Lit_Star '*'>}]
          spids: [72 75 82 -1]
        )
        (case_arm
          pat_list: [
            {<Id.Lit_Star '*'> (SQ <' --tee '>) <Id.Lit_Star '*'>}
            {<Id.Lit_Star '*'> (SQ <' --va'>) <Id.Lit_Star '*'>}
          ]
          action: [
            (C {<mkdir>} {<-p>} {<test-results>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:BASE)
                  op: assign_op.Equal
                  rhs: 
                    {<'test-results/'> 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<basename>} {(DQ ($ Id.VSub_Number '$0'))} {<.sh>})
                      )
                    }
                  spids: [105]
                )
              ]
            )
            (command.Pipeline
              children: [
                (command.Subshell
                  child: 
                    (command.CommandList
                      children: [
                        (command.Sentence
                          child: 
                            (command.Simple
                              words: [
                                {
                                  (braced_var_sub
                                    token: <Id.VSub_Name SHELL>
                                    suffix_op: 
                                      (suffix_op.Unary
                                        tok: <Id.VTest_Hyphen ->
                                        arg_word: {<sh>}
                                      )
                                  )
                                }
                                {(DQ ($ Id.VSub_Number '$0'))}
                                {(DQ ($ Id.VSub_At '$@'))}
                              ]
                              redirects: [
                                (redir
                                  op: <Id.Redir_GreatAnd '2>&'>
                                  loc: (redir_loc.Fd fd:2)
                                  arg: {<1>}
                                )
                              ]
                              more_env: [
                                (env_pair
                                  name: GIT_TEST_TEE_STARTED
                                  val: {<Id.KW_Done done>}
                                  spids: [119]
                                )
                              ]
                              do_fork: T
                            )
                          terminator: <Id.Op_Semi _>
                        )
                        (command.Simple
                          words: [{<echo>} {($ Id.VSub_QMark '$?')}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {($ Id.VSub_DollarName '$BASE') <.exit>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                    )
                )
                (C {<tee>} {($ Id.VSub_DollarName '$BASE') <.out>})
              ]
              negated: F
            )
            (C {<test>} 
              {
                (DQ 
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: (C {<cat>} {($ Id.VSub_DollarName '$BASE') <.exit>})
                  )
                )
              } {<Id.Lit_Equals '='>} {<0>}
            )
            (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
          ]
          spids: [84 95 178 -1]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:TEST_DIRECTORY)
          op: assign_op.Equal
          rhs: {(command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<pwd>})) <'/..'>}
          spids: [183]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:TEST_OUTPUT_DIRECTORY)
          op: assign_op.Equal
          rhs: {(command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<pwd>}))}
          spids: [189]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$GIT_TEST_INSTALLED'))})
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:perf_results_prefix)
                  op: assign_op.Equal
                  rhs: (word.Empty)
                  spids: [208]
                )
              ]
            )
          ]
          spids: [194 205]
        )
      ]
      else_action: [
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:perf_results_prefix)
              op: assign_op.Equal
              rhs: 
                {
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (command.Pipeline
                        children: [
                          (C {<printf>} {(DQ <'%s'>)} 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name GIT_TEST_INSTALLED>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      tok: <Id.VOp1_Percent '%'>
                                      arg_word: {<Id.Lit_Slash '/'> <bin-wrappers>}
                                    )
                                )
                              )
                            }
                          )
                          (C {<tr>} {<-c>} {(DQ <'[a-zA-Z0-9]'>)} {(DQ <'[_*]'>)})
                        ]
                        negated: F
                      )
                  ) (DQ <.>)
                }
              spids: [213]
            )
          ]
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:GIT_TEST_INSTALLED)
              op: assign_op.Equal
              rhs: 
                {
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (command.AndOr
                        ops: [Id.Op_DAmp]
                        children: [
                          (C {<cd>} {(DQ ($ Id.VSub_DollarName '$GIT_TEST_INSTALLED'))})
                          (C {<pwd>})
                        ]
                      )
                  )
                }
              spids: [253]
            )
          ]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:TEST_NO_CREATE_REPO)
          op: assign_op.Equal
          rhs: {<t>}
          spids: [269]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:TEST_NO_MALLOC_CHECK)
          op: assign_op.Equal
          rhs: {<t>}
          spids: [272]
        )
      ]
    )
    (C {<.>} {<'../test-lib.sh'>})
    (C {<export>} {<TEST_DIRECTORY>} {<TRASH_DIRECTORY>} {<GIT_BUILD_DIR>} {<GIT_TEST_CMP>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:MODERN_GIT)
          op: assign_op.Equal
          rhs: {($ Id.VSub_DollarName '$GIT_BUILD_DIR') <'/bin-wrappers/git'>}
          spids: [298]
        )
      ]
    )
    (C {<export>} {<MODERN_GIT>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:perf_results_dir)
          op: assign_op.Equal
          rhs: {($ Id.VSub_DollarName '$TEST_OUTPUT_DIRECTORY') <'/test-results'>}
          spids: [307]
        )
      ]
    )
    (C {<mkdir>} {<-p>} {(DQ ($ Id.VSub_DollarName '$perf_results_dir'))})
    (C {<rm>} {<-f>} 
      {(DQ ($ Id.VSub_DollarName '$perf_results_dir')) <'/'> 
        (command_sub
          left_token: <Id.Left_DollarParen '$('>
          child: (C {<basename>} {(DQ ($ Id.VSub_Number '$0'))} {<.sh>})
        ) <.subtests>
      }
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$GIT_PERF_REPEAT_COUNT'))})
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:GIT_PERF_REPEAT_COUNT)
                  op: assign_op.Equal
                  rhs: {<3>}
                  spids: [353]
                )
              ]
            )
          ]
          spids: [339 350]
        )
      ]
    )
    (command.ShFunction
      name: die_if_build_dir_not_repo
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.Pipeline
                              children: [
                                (command.Subshell
                                  child: 
                                    (command.AndOr
                                      ops: [Id.Op_DAmp]
                                      children: [
                                        (C {<cd>} 
                                          {(DQ ($ Id.VSub_DollarName '$TEST_DIRECTORY') <'/..'>)}
                                        )
                                        (command.Simple
                                          words: [{<git>} {<rev-parse>} {<--build-dir>}]
                                          redirects: [
                                            (redir
                                              op: <Id.Redir_Great '>'>
                                              loc: (redir_loc.Fd fd:1)
                                              arg: {<'/dev/null'>}
                                            )
                                            (redir
                                              op: <Id.Redir_GreatAnd '2>&'>
                                              loc: (redir_loc.Fd fd:2)
                                              arg: {<1>}
                                            )
                                          ]
                                          do_fork: T
                                        )
                                      ]
                                    )
                                )
                              ]
                              negated: T
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<error>} 
                      {
                        (DQ <'No '> ($ Id.VSub_Number '$1') 
                          <' defined, and your build directory is not a repo'>
                        )
                      }
                    )
                  ]
                  spids: [366 397]
                )
              ]
            )
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$GIT_PERF_REPO'))})
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (C {<die_if_build_dir_not_repo>} {(SQ <'$GIT_PERF_REPO'>)})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:GIT_PERF_REPO)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$TEST_DIRECTORY') <'/..'>}
                  spids: [435]
                )
              ]
            )
          ]
          spids: [414 425]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$GIT_PERF_LARGE_REPO'))})
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (C {<die_if_build_dir_not_repo>} {(SQ <'$GIT_PERF_LARGE_REPO'>)})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:GIT_PERF_LARGE_REPO)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$TEST_DIRECTORY') <'/..'>}
                  spids: [462]
                )
              ]
            )
          ]
          spids: [441 452]
        )
      ]
    )
    (command.ShFunction
      name: test_perf_create_repo_from
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} {(DQ ($ Id.VSub_Pound '$#'))} {<Id.Lit_Equals '='>} {<2>})
                (C {<error>} {(DQ <'bug in the test script: not 2 parameters to test-create-repo'>)})
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:repo)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number '$1'))}
                  spids: [497]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:source)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number '$2'))}
                  spids: [503]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:source_git)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: 
                            (C {<git>} {<-C>} {(DQ ($ Id.VSub_DollarName '$source'))} {<rev-parse>} 
                              {<--git-dir>}
                            )
                        )
                      )
                    }
                  spids: [509]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:objects_dir)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: 
                            (C {(DQ ($ Id.VSub_DollarName '$MODERN_GIT'))} {<-C>} 
                              {(DQ ($ Id.VSub_DollarName '$source'))} {<rev-parse>} {<--git-path>} {<objects>}
                            )
                        )
                      )
                    }
                  spids: [527]
                )
              ]
            )
            (C {<mkdir>} {<-p>} {(DQ ($ Id.VSub_DollarName '$repo') <'/.git'>)})
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DPipe]
              children: [
                (command.Subshell
                  child: 
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DAmp]
                      children: [
                        (C {<cd>} {(DQ ($ Id.VSub_DollarName '$source'))})
                        (BraceGroup
                          children: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Id.Op_DPipe]
                                  children: [
                                    (command.Simple
                                      words: [
                                        {<cp>}
                                        {<-Rl>}
                                        {(DQ ($ Id.VSub_DollarName '$objects_dir'))}
                                        {(DQ ($ Id.VSub_DollarName '$repo') <'/.git/'>)}
                                      ]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_Great '2>'>
                                          loc: (redir_loc.Fd fd:2)
                                          arg: {<'/dev/null'>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                    (C {<cp>} {<-R>} {(DQ ($ Id.VSub_DollarName '$objects_dir'))} 
                                      {(DQ ($ Id.VSub_DollarName '$repo') <'/.git/'>)}
                                    )
                                  ]
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                        (command.ForEach
                          iter_names: [stuff]
                          iterable: 
                            (for_iter.Words
                              words: [
                                {(DQ ($ Id.VSub_DollarName '$source_git')) <'/'> <Id.Lit_Star '*'>}
                              ]
                            )
                          body: 
                            (command.DoGroup
                              children: [
                                (command.Case
                                  to_match: {(DQ ($ Id.VSub_DollarName '$stuff'))}
                                  arms: [
                                    (case_arm
                                      pat_list: [
                                        {<Id.Lit_Star '*'> <'/objects'>}
                                        {<Id.Lit_Star '*'> <'/hooks'>}
                                        {<Id.Lit_Star '*'> <'/config'>}
                                        {<Id.Lit_Star '*'> <'/commondir'>}
                                      ]
                                      spids: [636 647 650 -1]
                                    )
                                    (case_arm
                                      pat_list: [{<Id.Lit_Star '*'>}]
                                      action: [
                                        (command.AndOr
                                          ops: [Id.Op_DPipe]
                                          children: [
                                            (C {<cp>} {<-R>} {(DQ ($ Id.VSub_DollarName '$stuff'))} 
                                              {(DQ ($ Id.VSub_DollarName '$repo') <'/.git/'>)}
                                            )
                                            (command.ControlFlow
                                              token: <Id.ControlFlow_Exit exit>
                                              arg_word: {<1>}
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [653 654 677 -1]
                                    )
                                  ]
                                )
                              ]
                            )
                        )
                      ]
                    )
                )
                (command.Subshell
                  child: 
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp]
                      children: [
                        (C {<cd>} {(DQ ($ Id.VSub_DollarName '$repo'))})
                        (C {<git>} {<init>} {<-q>})
                        (BraceGroup
                          children: [
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<test_have_prereq>} {<SYMLINKS>})
                                (C {<git>} {<config>} {<core.symlinks>} {<false>})
                              ]
                            )
                          ]
                        )
                        (command.Simple
                          words: [{<mv>} {<'.git/hooks'>} {<'.git/hooks-disabled'>}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '2>'>
                              loc: (redir_loc.Fd fd:2)
                              arg: {<'/dev/null'>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                    )
                )
                (C {<error>} 
                  {
                    (DQ <'failed to copy repository \''> ($ Id.VSub_DollarName '$source') <'\' to \''> 
                      ($ Id.VSub_DollarName '$repo') <'\''>
                    )
                  }
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: test_perf_default_repo
      body: 
        (BraceGroup
          children: [
            (C {<test_perf_create_repo_from>} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Number 1>
                    suffix_op: 
                      (suffix_op.Unary
                        tok: <Id.VTest_ColonHyphen ':-'>
                        arg_word: {($ Id.VSub_DollarName '$TRASH_DIRECTORY')}
                      )
                  )
                )
              } {(DQ ($ Id.VSub_DollarName '$GIT_PERF_REPO'))}
            )
          ]
        )
    )
    (command.ShFunction
      name: test_perf_large_repo
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<test>} {(DQ ($ Id.VSub_DollarName '$GIT_PERF_LARGE_REPO'))} 
                              {<Id.Lit_Equals '='>} {(DQ ($ Id.VSub_DollarName '$GIT_BUILD_DIR'))}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Simple
                      words: [
                        {<echo>}
                        {
                          (DQ <'warning: '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                            <'GIT_PERF_LARGE_REPO is '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <GIT_BUILD_DIR.>
                          )
                        }
                      ]
                      redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                      do_fork: T
                    )
                    (command.Simple
                      words: [
                        {<echo>}
                        {(DQ <'warning: This will work, but may not be a sufficiently large repo'>)}
                      ]
                      redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                      do_fork: T
                    )
                    (command.Simple
                      words: [{<echo>} {(DQ <'warning: for representative measurements.'>)}]
                      redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                      do_fork: T
                    )
                  ]
                  spids: [797 812]
                )
              ]
            )
            (C {<test_perf_create_repo_from>} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Number 1>
                    suffix_op: 
                      (suffix_op.Unary
                        tok: <Id.VTest_ColonHyphen ':-'>
                        arg_word: {($ Id.VSub_DollarName '$TRASH_DIRECTORY')}
                      )
                  )
                )
              } {(DQ ($ Id.VSub_DollarName '$GIT_PERF_LARGE_REPO'))}
            )
          ]
        )
    )
    (command.ShFunction
      name: test_checkout_worktree
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<git>} {<checkout-index>} {<-u>} {<-a>})
                (C {<error>} {(DQ <'git checkout-index failed'>)})
              ]
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:immediate)
          op: assign_op.Equal
          rhs: {<t>}
          spids: [899]
        )
      ]
    )
    (command.Case
      to_match: {(DQ (command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<uname>} {<-s>})))}
      arms: [
        (case_arm
          pat_list: [{<Darwin>}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:GTIME)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (braced_var_sub
                          token: <Id.VSub_Name GTIME>
                          suffix_op: 
                            (suffix_op.Unary
                              tok: <Id.VTest_ColonHyphen ':-'>
                              arg_word: {<gtime>}
                            )
                        )
                      )
                    }
                  spids: [921]
                )
              ]
            )
          ]
          spids: [918 919 929 -1]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:GTIME)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                (braced_var_sub
                  token: <Id.VSub_Name GTIME>
                  suffix_op: 
                    (suffix_op.Unary
                      tok: <Id.VTest_ColonHyphen ':-'>
                      arg_word: 
                        {<Id.Lit_Slash '/'> <usr> <Id.Lit_Slash '/'> <bin> <Id.Lit_Slash '/'> <time>}
                    )
                )
              )
            }
          spids: [933]
        )
      ]
    )
    (command.ShFunction
      name: test_run_perf_
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:test_cleanup)
                  op: assign_op.Equal
                  rhs: {<Id.Lit_Colon ':'>}
                  spids: [956]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:test_export_)
                  op: assign_op.Equal
                  rhs: {(DQ <test_cleanup>)}
                  spids: [960]
                )
              ]
            )
            (C {<export>} {<test_cleanup>} {<test_export_>})
            (command.Simple
              words: [
                {(DQ ($ Id.VSub_DollarName '$GTIME'))}
                {<-f>}
                {(DQ <'%E %U %S'>)}
                {<-o>}
                {<test_time.> ($ Id.VSub_DollarName '$i')}
                {(DQ ($ Id.VSub_DollarName '$SHELL'))}
                {<-c>}
                {(SQ <'\n'> <'. '>) (DQ ($ Id.VSub_DollarName '$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 ($ Id.VSub_Number '$1')) (SQ <'\n'> <'ret=$?\n'> <'set | sed -n "s'>) 
                  (DQ <'/\'/\''> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\\'>) 
                    (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\\'>) <'\'\'/g'>
                  ) (SQ <';s/^\\\\($test_export_\\\\)/export '>) (DQ <'\'&\''>) (SQ <'/p" >test_vars\n'> <'exit $ret'>)
                }
              ]
              redirects: [
                (redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<3>})
                (redir op:<Id.Redir_GreatAnd '2>&'> loc:(redir_loc.Fd fd:2) arg:{<4>})
              ]
              do_fork: T
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:eval_ret)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '$?')}
                  spids: [1043]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.AndOr
                          ops: [Id.Op_DPipe]
                          children: [
                            (C {<test>} {($ Id.VSub_DollarName '$eval_ret')} {<Id.Lit_Equals '='>} {<0>})
                            (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$expecting_failure'))})
                          ]
                        )
                      ]
                    )
                  action: [
                    (C {<test_eval_>} {(DQ ($ Id.VSub_DollarName '$test_cleanup'))})
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<.>} {<'./test_vars'>})
                        (C {<error>} {(DQ <'failed to load updated environment'>)})
                      ]
                    )
                  ]
                  spids: [1048 1069]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<test>} {(DQ ($ Id.VSub_DollarName '$verbose'))} 
                                  {<Id.Lit_Equals '='>} {(DQ <t>)}
                                )
                                (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$HARNESS_ACTIVE'))})
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<echo>} {(DQ )})]
                  spids: [1095 1120]
                )
              ]
            )
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {(DQ ($ Id.VSub_DollarName '$eval_ret'))}
            )
          ]
        )
    )
    (command.ShFunction
      name: test_perf
      body: 
        (BraceGroup
          children: [
            (C {<test_start_>})
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DPipe]
              children: [
                (C {<test>} {(DQ ($ Id.VSub_Pound '$#'))} {<Id.Lit_Equals '='>} {<3>})
                (BraceGroup
                  children: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:test_prereq)
                              op: assign_op.Equal
                              rhs: {($ Id.VSub_Number '$1')}
                              spids: [1167]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (command.Sentence
                      child: (C {<shift>})
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:test_prereq)
                      op: assign_op.Equal
                      rhs: (word.Empty)
                      spids: [1178]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} {(DQ ($ Id.VSub_Pound '$#'))} {<Id.Lit_Equals '='>} {<2>})
                (C {<error>} 
                  {(DQ <'bug in the test script: not 2 or 3 parameters to test-expect-success'>)}
                )
              ]
            )
            (C {<export>} {<test_prereq>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Pipeline
                          children: [(C {<test_skip>} {(DQ ($ Id.VSub_At '$@'))})]
                          negated: T
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:base)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<basename>} {(DQ ($ Id.VSub_Number '$0'))} {<.sh>})
                              )
                            }
                          spids: [1220]
                        )
                      ]
                    )
                    (command.Simple
                      words: [{<echo>} {(DQ ($ Id.VSub_DollarName '$test_count'))}]
                      redirects: [
                        (redir
                          op: <Id.Redir_DGreat '>>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: 
                            {(DQ ($ Id.VSub_DollarName '$perf_results_dir')) <'/'> 
                              ($ Id.VSub_DollarName '$base') <.subtests>
                            }
                        )
                      ]
                      do_fork: T
                    )
                    (command.Simple
                      words: [{<echo>} {(DQ ($ Id.VSub_Number '$1'))}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: 
                            {(DQ ($ Id.VSub_DollarName '$perf_results_dir')) <'/'> 
                              ($ Id.VSub_DollarName '$base') <.> ($ Id.VSub_DollarName '$test_count') <.descr>
                            }
                        )
                      ]
                      do_fork: T
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$verbose'))})
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<printf>} {(DQ <'%s'>)} 
                              {
                                (DQ <'perf '> ($ Id.VSub_DollarName '$test_count') <' - '> 
                                  ($ Id.VSub_Number '$1') <':'>
                                )
                              }
                            )
                          ]
                          spids: [1264 1275]
                        )
                      ]
                      else_action: [
                        (C {<echo>} 
                          {
                            (DQ <'perf '> ($ Id.VSub_DollarName '$test_count') <' - '> 
                              ($ Id.VSub_Number '$1') <':'>
                            )
                          }
                        )
                      ]
                    )
                    (command.ForEach
                      iter_names: [i]
                      iterable: 
                        (for_iter.Words
                          words: [
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<test_seq>} {<1>} 
                                    {($ Id.VSub_DollarName '$GIT_PERF_REPEAT_COUNT')}
                                  )
                              )
                            }
                          ]
                        )
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Simple
                              words: [{<say>} {(DQ <'running: '> ($ Id.VSub_Number '$2'))}]
                              redirects: [
                                (redir
                                  op: <Id.Redir_GreatAnd '>&'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {<3>}
                                )
                              ]
                              do_fork: T
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [(C {<test_run_perf_>} {(DQ ($ Id.VSub_Number '$2'))})]
                                    )
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (command.Sentence
                                                  child: 
                                                    (C {<test>} {<-z>} 
                                                      {(DQ ($ Id.VSub_DollarName '$verbose'))}
                                                    )
                                                  terminator: <Id.Op_Semi _>
                                                )
                                              ]
                                            )
                                          action: [
                                            (C {<printf>} {(DQ <' %s'>)} 
                                              {(DQ ($ Id.VSub_DollarName '$i'))}
                                            )
                                          ]
                                          spids: [1351 1362]
                                        )
                                      ]
                                      else_action: [
                                        (C {<echo>} 
                                          {
                                            (DQ <'* timing run '> ($ Id.VSub_DollarName '$i') <'/'> 
                                              ($ Id.VSub_DollarName '$GIT_PERF_REPEAT_COUNT') <':'>
                                            )
                                          }
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [1339 1348]
                                )
                              ]
                              else_action: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$verbose'))})
                                    (C {<echo>})
                                  ]
                                )
                                (C {<test_failure_>} {(DQ ($ Id.VSub_At '$@'))})
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Break break>
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$verbose'))})
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<echo>} {(DQ <' ok'>)})]
                          spids: [1425 1436]
                        )
                      ]
                      else_action: [(C {<test_ok_>} {(DQ ($ Id.VSub_Number '$1'))})]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:base)
                          op: assign_op.Equal
                          rhs: 
                            {(DQ ($ Id.VSub_DollarName '$perf_results_dir')) <'/'> 
                              (DQ ($ Id.VSub_DollarName '$perf_results_prefix') 
                                (command_sub
                                  left_token: <Id.Left_DollarParen '$('>
                                  child: (C {<basename>} {(DQ ($ Id.VSub_Number '$0'))} {<.sh>})
                                )
                              ) <.> (DQ ($ Id.VSub_DollarName '$test_count'))
                            }
                          spids: [1459]
                        )
                      ]
                    )
                    (command.Simple
                      words: [
                        {(DQ ($ Id.VSub_DollarName '$TEST_DIRECTORY')) <'/perf/min_time.perl'>}
                        {<test_time.> <Id.Lit_Star '*'>}
                      ]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName '$base')) <.times>}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  spids: [1206 1217]
                )
              ]
            )
            (C {<test_finish_>})
          ]
        )
    )
    (command.ShFunction
      name: test_at_end_hook_
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<test>} {<-z>} 
                              {(DQ ($ Id.VSub_DollarName '$GIT_PERF_AGGREGATING_LATER'))}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Subshell
                      child: 
                        (command.AndOr
                          ops: [Id.Op_DAmp]
                          children: [
                            (C {<cd>} {(DQ ($ Id.VSub_DollarName '$TEST_DIRECTORY')) <'/perf'>})
                            (C {<'./aggregate.perl'>} 
                              {
                                (command_sub
                                  left_token: <Id.Left_DollarParen '$('>
                                  child: (C {<basename>} {(DQ ($ Id.VSub_Number '$0'))})
                                )
                              }
                            )
                          ]
                        )
                    )
                  ]
                  spids: [1519 1530]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: test_export
      body: (BraceGroup children:[(C {<export>} {(DQ ($ Id.VSub_At '$@'))})])
    )
  ]
)