(command.CommandList
  children: [
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$TEST_DIRECTORY'))})]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:TEST_DIRECTORY spids:[88])
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: (command.CommandList children:[(C {(pwd)})])
                        left_token: <Left_CommandSub '$('>
                        spids: [89 91]
                      )
                    }
                  spids: [88]
                )
              ]
              spids: [88]
            )
          ]
          spids: [16777215 73]
        )
      ]
      else_action: [
        (command.AndOr
          ops: [Op_DPipe]
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:TEST_DIRECTORY spids:[104])
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.AndOr
                                ops: [Op_DAmp]
                                children: [(C {(cd)} {(DQ ($ VSub_Name '$TEST_DIRECTORY'))}) (C {(pwd)})]
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [105 115]
                      )
                    }
                  spids: [104]
                )
              ]
              spids: [104]
            )
            (command.ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
          ]
        )
      ]
      spids: [93 123]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$TEST_OUTPUT_DIRECTORY'))})]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:TEST_OUTPUT_DIRECTORY spids:[146])
                  op: Equal
                  rhs: {($ VSub_Name '$TEST_DIRECTORY')}
                  spids: [146]
                )
              ]
              spids: [146]
            )
          ]
          spids: [16777215 135]
        )
      ]
      spids: [16777215 149]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:GIT_BUILD_DIR spids:[151])
          op: Equal
          rhs: {(DQ ($ VSub_Name '$TEST_DIRECTORY')) (/..)}
          spids: [151]
        )
      ]
      spids: [151]
    )
    (command.SimpleCommand
      words: [{(DQ ($ VSub_Name '$GIT_BUILD_DIR') (/git))}]
      redirects: [(redir.Redir op:<Redir_Great '>'> fd:16777215 arg_word:{(/dev/null)})]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {($ VSub_QMark '$?')} {(KW_Bang '!') (Lit_Other '=')} {(1)})]
          action: [
            (command.SimpleCommand
              words: [{(echo)} {(SQ <'error: you do not seem to have built git yet.'>)}]
              redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
            )
            (command.ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
          ]
          spids: [16777215 183]
        )
      ]
      spids: [16777215 200]
    )
    (C {(.)} {(DQ ($ VSub_Name '$GIT_BUILD_DIR')) (/GIT-BUILD-OPTIONS)})
    (C {(export)} {(PERL_PATH)} {(SHELL_PATH)})
    (command.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: [234 237 244 16777215]
        )
        (case_arm
          pat_list: [
            {(Lit_Other '*') (SQ <' --tee '>) (Lit_Other '*')}
            {(Lit_Other '*') (SQ <' --va'>) (Lit_Other '*')}
            {(Lit_Other '*') (SQ <' --verbose-log '>) (Lit_Other '*')}
          ]
          action: [
            (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name '$TEST_OUTPUT_DIRECTORY') (/test-results))})
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:BASE spids:[276])
                  op: Equal
                  rhs: 
                    {
                      (DQ ($ VSub_Name '$TEST_OUTPUT_DIRECTORY') (/test-results/) 
                        (word_part.CommandSubPart
                          command_list: 
                            (command.CommandList
                              children: [(C {(basename)} {(DQ ($ VSub_Number '$0'))} {(.sh)})]
                            )
                          left_token: <Left_CommandSub '$('>
                          spids: [280 288]
                        )
                      )
                    }
                  spids: [276]
                )
              ]
              spids: [276]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:GIT_TEST_TEE_OUTPUT_FILE spids:[301])
                  op: Equal
                  rhs: {($ VSub_Name '$BASE') (.out)}
                  spids: [301]
                )
              ]
              spids: [301]
            )
            (C {(export)} {(GIT_TEST_TEE_OUTPUT_FILE)})
            (command.SimpleCommand
              redirects: [
                (redir.Redir
                  op: <Redir_Great '>'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$GIT_TEST_TEE_OUTPUT_FILE'))}
                )
              ]
            )
            (command.Pipeline
              children: [
                (command.Subshell
                  child: 
                    (command.CommandList
                      children: [
                        (command.Sentence
                          child: 
                            (command.SimpleCommand
                              words: [
                                {(${ VSub_Name SHELL_PATH)}
                                {(DQ ($ VSub_Number '$0'))}
                                {(DQ ($ VSub_At '$@'))}
                              ]
                              redirects: [(redir.Redir op:<Redir_GreatAnd '2>&'> fd:2 arg_word:{(1)})]
                              more_env: [
                                (env_pair
                                  name: GIT_TEST_TEE_STARTED
                                  val: {(KW_Done done)}
                                  spids: [328]
                                )
                              ]
                            )
                          terminator: <Op_Semi ';'>
                        )
                        (command.SimpleCommand
                          words: [{(echo)} {($ VSub_QMark '$?')}]
                          redirects: [
                            (redir.Redir
                              op: <Redir_Great '>'>
                              fd: 16777215
                              arg_word: {(DQ ($ VSub_Name '$BASE') (.exit))}
                            )
                          ]
                        )
                      ]
                    )
                  spids: [327 357]
                )
                (C {(tee)} {(-a)} {(DQ ($ VSub_Name '$GIT_TEST_TEE_OUTPUT_FILE'))})
              ]
              negated: F
            )
            (C {(test)} 
              {
                (DQ 
                  (word_part.CommandSubPart
                    command_list: 
                      (command.CommandList
                        children: [(C {(cat)} {(DQ ($ VSub_Name '$BASE') (.exit))})]
                      )
                    left_token: <Left_CommandSub '$('>
                    spids: [373 380]
                  )
                )
              } {(Lit_Other '=')} {(0)}
            )
            (command.ControlFlow token:<ControlFlow_Exit exit>)
          ]
          spids: [246 263 391 16777215]
        )
      ]
      spids: [223 232 393]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:LANG spids:[402])
          op: Equal
          rhs: {(C)}
          spids: [402]
        )
      ]
      spids: [402]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:LC_ALL spids:[405])
          op: Equal
          rhs: {(C)}
          spids: [405]
        )
      ]
      spids: [405]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:PAGER spids:[408])
          op: Equal
          rhs: {(cat)}
          spids: [408]
        )
      ]
      spids: [408]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:TZ spids:[411])
          op: Equal
          rhs: {(UTC)}
          spids: [411]
        )
      ]
      spids: [411]
    )
    (C {(export)} {(LANG)} {(LC_ALL)} {(PAGER)} {(TZ)})
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:EDITOR spids:[424])
          op: Equal
          rhs: {(Lit_Other ':')}
          spids: [424]
        )
      ]
      spids: [424]
    )
    (C {(unset)} {(VISUAL)} {(EMAIL)} {(LANGUAGE)} {(COLUMNS)} 
      {
        (word_part.CommandSubPart
          command_list: 
            (command.CommandList
              children: [
                (C {(DQ ($ VSub_Name '$PERL_PATH'))} {(-e)} 
                  {
                    (SQ <'\n'> <'\tmy @env = keys %ENV;\n'> <'\tmy $ok = join("|", qw(\n'> 
                      <'\t\tTRACE\n'> <'\t\tDEBUG\n'> <'\t\tUSE_LOOKUP\n'> <'\t\tTEST\n'> <'\t\t.*_TEST\n'> <'\t\tPROVE\n'> <'\t\tVALGRIND\n'> 
                      <'\t\tUNZIP\n'> <'\t\tPERF_\n'> <'\t\tCURL_VERBOSE\n'> <'\t\tTRACE_CURL\n'> <'\t));\n'> 
                      <'\tmy @vars = grep(/^GIT_/ && !/^GIT_($ok)/o, @env);\n'> <'\tprint join("\\n", @vars);\n'>
                    )
                  }
                )
              ]
            )
          left_token: <Left_CommandSub '$('>
          spids: [449 475]
        )
      }
    )
    (C {(unset)} {(XDG_CONFIG_HOME)})
    (C {(unset)} {(GITPERLLIB)})
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:GIT_AUTHOR_EMAIL spids:[485])
          op: Equal
          rhs: {(author) (Lit_Other '@') (example.com)}
          spids: [485]
        )
      ]
      spids: [485]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:GIT_AUTHOR_NAME spids:[490])
          op: Equal
          rhs: {(SQ <'A U Thor'>)}
          spids: [490]
        )
      ]
      spids: [490]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:GIT_COMMITTER_EMAIL spids:[495])
          op: Equal
          rhs: {(committer) (Lit_Other '@') (example.com)}
          spids: [495]
        )
      ]
      spids: [495]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:GIT_COMMITTER_NAME spids:[500])
          op: Equal
          rhs: {(SQ <'C O Mitter'>)}
          spids: [500]
        )
      ]
      spids: [500]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:GIT_MERGE_VERBOSITY spids:[505])
          op: Equal
          rhs: {(5)}
          spids: [505]
        )
      ]
      spids: [505]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:GIT_MERGE_AUTOEDIT spids:[508])
          op: Equal
          rhs: {(no)}
          spids: [508]
        )
      ]
      spids: [508]
    )
    (C {(export)} {(GIT_MERGE_VERBOSITY)} {(GIT_MERGE_AUTOEDIT)})
    (C {(export)} {(GIT_AUTHOR_EMAIL)} {(GIT_AUTHOR_NAME)})
    (C {(export)} {(GIT_COMMITTER_EMAIL)} {(GIT_COMMITTER_NAME)})
    (C {(export)} {(EDITOR)})
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:GIT_TRACE_BARE spids:[537])
          op: Equal
          rhs: {(1)}
          spids: [537]
        )
      ]
      spids: [537]
    )
    (C {(export)} {(GIT_TRACE_BARE)})
    (command.If
      arms: [
        (if_arm
          cond: [
            (C {(test)} {(-n)} 
              {
                (DQ 
                  (word_part.BracedVarSub
                    token: <VSub_Name TEST_GIT_INDEX_VERSION>
                    suffix_op: (suffix_op.StringUnary op_id:VTest_ColonPlus arg_word:{(isset)})
                    spids: [552 556]
                  )
                )
              }
            )
          ]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:GIT_INDEX_VERSION spids:[562])
                  op: Equal
                  rhs: {(DQ ($ VSub_Name '$TEST_GIT_INDEX_VERSION'))}
                  spids: [562]
                )
              ]
              spids: [562]
            )
            (C {(export)} {(GIT_INDEX_VERSION)})
          ]
          spids: [16777215 559]
        )
      ]
      spids: [16777215 572]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.SimpleCommand
                  words: [
                    {(expr)}
                    {(DQ (' ') ($ VSub_Name '$GIT_TEST_OPTS') (' '))}
                    {(Lit_Other ':')}
                    {(DQ ('.* --valgrind '))}
                  ]
                  redirects: [(redir.Redir op:<Redir_Great '>'> fd:16777215 arg_word:{(/dev/null)})]
                )
                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$TEST_NO_MALLOC_CHECK'))})
              ]
            )
          ]
          action: [
            (command.FuncDef
              name: setup_malloc_check
              body: (command.BraceGroup children:[(C {(Lit_Other ':')} {(nothing)})] spids:[619])
              spids: [614 618]
            )
            (command.FuncDef
              name: teardown_malloc_check
              body: (command.BraceGroup children:[(C {(Lit_Other ':')} {(nothing)})] spids:[635])
              spids: [630 634]
            )
          ]
          spids: [16777215 611]
        )
      ]
      else_action: [
        (command.FuncDef
          name: setup_malloc_check
          body: 
            (command.BraceGroup
              children: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:MALLOC_CHECK_ spids:[656])
                      op: Equal
                      rhs: {(3)}
                      spids: [656]
                    )
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:MALLOC_PERTURB_ spids:[659])
                      op: Equal
                      rhs: {(165)}
                      spids: [659]
                    )
                  ]
                  spids: [656]
                )
                (C {(export)} {(MALLOC_CHECK_)} {(MALLOC_PERTURB_)})
              ]
              spids: [653]
            )
          spids: [648 652]
        )
        (command.FuncDef
          name: teardown_malloc_check
          body: 
            (command.BraceGroup
              children: [(C {(unset)} {(MALLOC_CHECK_)} {(MALLOC_PERTURB_)})]
              spids: [678]
            )
          spids: [673 677]
        )
      ]
      spids: [645 690]
    )
    (C {(Lit_Other ':')} 
      {
        (word_part.BracedVarSub
          token: <VSub_Name ASAN_OPTIONS>
          suffix_op: (suffix_op.StringUnary op_id:VTest_Equals arg_word:{('detect_leaks=0')})
          spids: [695 699]
        )
      }
    )
    (C {(export)} {(ASAN_OPTIONS)})
    (C {(unset)} {(CDPATH)})
    (C {(unset)} {(GREP_OPTIONS)})
    (C {(unset)} {(UNZIP)})
    (command.Case
      to_match: 
        {
          (word_part.CommandSubPart
            command_list: 
              (command.CommandList
                children: [
                  (command.Pipeline
                    children: [
                      (C {(echo)} {($ VSub_Name '$GIT_TRACE')})
                      (C {(tr)} {(DQ ('[A-Z]'))} {(DQ ('[a-z]'))})
                    ]
                    negated: F
                  )
                ]
              )
            left_token: <Left_CommandSub '$('>
            spids: [728 743]
          )
        }
      arms: [
        (case_arm
          pat_list: [{(1)} {(2)} {(true)}]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:GIT_TRACE spids:[755])
                  op: Equal
                  rhs: {(4)}
                  spids: [755]
                )
              ]
              spids: [755]
            )
          ]
          spids: [747 752 759 16777215]
        )
      ]
      spids: [726 745 761]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:_x05 spids:[773])
          op: Equal
          rhs: {(SQ <'[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'>)}
          spids: [773]
        )
      ]
      spids: [773]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:_x40 spids:[778])
          op: Equal
          rhs: 
            {
              (DQ ($ VSub_Name '$_x05') ($ VSub_Name '$_x05') ($ VSub_Name '$_x05') 
                ($ VSub_Name '$_x05') ($ VSub_Name '$_x05') ($ VSub_Name '$_x05') ($ VSub_Name '$_x05') ($ VSub_Name '$_x05')
              )
            }
          spids: [778]
        )
      ]
      spids: [778]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:_z40 spids:[794])
          op: Equal
          rhs: {(0000000000000000000000000000000000000000)}
          spids: [794]
        )
      ]
      spids: [794]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:EMPTY_TREE spids:[798])
          op: Equal
          rhs: {(4b825dc642cb6eb9a060e54bf8d69288fbee4904)}
          spids: [798]
        )
      ]
      spids: [798]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:EMPTY_BLOB spids:[801])
          op: Equal
          rhs: {(e69de29bb2d1d6434b8b29ae775ad8c2e48c5391)}
          spids: [801]
        )
      ]
      spids: [801]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:LF spids:[808])
          op: Equal
          rhs: {(SQ <'\n'>)}
          spids: [808]
        )
      ]
      spids: [808]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:u200c spids:[820])
          op: Equal
          rhs: 
            {
              (word_part.CommandSubPart
                command_list: 
                  (command.CommandList
                    children: [(C {(printf)} {(SQ <'\\342\\200\\214'>)})]
                  )
                left_token: <Left_CommandSub '$('>
                spids: [821 827]
              )
            }
          spids: [820]
        )
      ]
      spids: [820]
    )
    (C {(export)} {(_x05)} {(_x40)} {(_z40)} {(LF)} {(u200c)} {(EMPTY_TREE)} {(EMPTY_BLOB)})
    (command.AndOr
      ops: [Op_DAmp Op_DAmp]
      children: [
        (C {(test)} {(DQ (x) ($ VSub_Name '$TERM'))} {(KW_Bang '!') (Lit_Other '=')} {(DQ (xdumb))})
        (command.Subshell
          child: 
            (command.AndOr
              ops: [Op_DAmp Op_DAmp Op_DAmp]
              children: [
                (C {(test)} {(-t)} {(1)})
                (command.SimpleCommand
                  words: [{(tput)} {(bold)}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(/dev/null)}
                    )
                    (redir.Redir op:<Redir_GreatAnd '2>&'> fd:2 arg_word:{(1)})
                  ]
                )
                (command.SimpleCommand
                  words: [{(tput)} {(setaf)} {(1)}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(/dev/null)}
                    )
                    (redir.Redir op:<Redir_GreatAnd '2>&'> fd:2 arg_word:{(1)})
                  ]
                )
                (command.SimpleCommand
                  words: [{(tput)} {(sgr0)}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(/dev/null)}
                    )
                    (redir.Redir op:<Redir_GreatAnd '2>&'> fd:2 arg_word:{(1)})
                  ]
                )
              ]
            )
          spids: [881 932]
        )
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:color spids:[937])
              op: Equal
              rhs: {(t)}
              spids: [937]
            )
          ]
          spids: [937]
        )
      ]
    )
    (command.WhileUntil
      keyword: <KW_While while>
      cond: [(C {(test)} {(DQ ($ VSub_Pound '$#'))} {(-ne)} {(0)})]
      body: 
        (command.DoGroup
          children: [
            (command.Case
              to_match: {(DQ ($ VSub_Number '$1'))}
              arms: [
                (case_arm
                  pat_list: [{(-d)} {(--d)} {(--de)} {(--deb)} {(--debu)} {(--debug)}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:debug spids:[979])
                              op: Equal
                              rhs: {(t)}
                              spids: [979]
                            )
                          ]
                          spids: [979]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                  ]
                  spids: [965 976 985 16777215]
                )
                (case_arm
                  pat_list: [
                    {(-i)}
                    {(--i)}
                    {(--im)}
                    {(--imm)}
                    {(--imme)}
                    {(--immed)}
                    {(--immedi)}
                    {(--immedia)}
                    {(--immediat)}
                    {(--immediate)}
                  ]
                  action: [
                    (command.Sentence
                      child: 
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:immediate spids:[1010])
                              op: Equal
                              rhs: {(t)}
                              spids: [1010]
                            )
                          ]
                          spids: [1010]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                  ]
                  spids: [988 1007 1016 16777215]
                )
                (case_arm
                  pat_list: [
                    {(-l)}
                    {(--l)}
                    {(--lo)}
                    {(--lon)}
                    {(--long)}
                    {(--long-)}
                    {(--long-t)}
                    {(--long-te)}
                    {(--long-tes)}
                    {(--long-test)}
                    {(--long-tests)}
                  ]
                  action: [
                    (command.Sentence
                      child: 
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:GIT_TEST_LONG spids:[1043])
                              op: Equal
                              rhs: {(t)}
                              spids: [1043]
                            )
                          ]
                          spids: [1043]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (command.Sentence
                      child: (C {(export)} {(GIT_TEST_LONG)})
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                  ]
                  spids: [1019 1040 1054 16777215]
                )
                (case_arm
                  pat_list: [{(-r)}]
                  action: [
                    (command.Sentence
                      child: (C {(shift)})
                      terminator: <Op_Semi ';'>
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {(DQ ($ VSub_Pound '$#'))} {(-ne)} {(0)})
                        (command.BraceGroup
                          children: [
                            (command.Sentence
                              child: 
                                (command.SimpleCommand
                                  words: [{(echo)} {(SQ <'error: -r requires an argument'>)}]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_GreatAnd '>&'>
                                      fd: 16777215
                                      arg_word: {(2)}
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                            (command.Sentence
                              child: (command.ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          spids: [1076]
                        )
                      ]
                    )
                    (command.Sentence
                      child: 
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:run_list spids:[1099])
                              op: Equal
                              rhs: {($ VSub_Number '$1')}
                              spids: [1099]
                            )
                          ]
                          spids: [1099]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                  ]
                  spids: [1057 1058 1105 16777215]
                )
                (case_arm
                  pat_list: [{(--run) (Lit_Other '=') (Lit_Other '*')}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:run_list spids:[1114])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.BracedVarSub
                                    token: <VSub_Number 1>
                                    suffix_op: 
                                      (suffix_op.StringUnary
                                        op_id: VOp1_Pound
                                        arg_word: {('--*=')}
                                      )
                                    spids: [1115 1119]
                                  )
                                }
                              spids: [1114]
                            )
                          ]
                          spids: [1114]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                  ]
                  spids: [1108 1111 1124 16777215]
                )
                (case_arm
                  pat_list: [{(-h)} {(--h)} {(--he)} {(--hel)} {(--help)}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:help spids:[1139])
                              op: Equal
                              rhs: {(t)}
                              spids: [1139]
                            )
                          ]
                          spids: [1139]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                  ]
                  spids: [1127 1136 1145 16777215]
                )
                (case_arm
                  pat_list: [
                    {(-v)}
                    {(--v)}
                    {(--ve)}
                    {(--ver)}
                    {(--verb)}
                    {(--verbo)}
                    {(--verbos)}
                    {(--verbose)}
                  ]
                  action: [
                    (command.Sentence
                      child: 
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:verbose spids:[1166])
                              op: Equal
                              rhs: {(t)}
                              spids: [1166]
                            )
                          ]
                          spids: [1166]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                  ]
                  spids: [1148 1163 1172 16777215]
                )
                (case_arm
                  pat_list: [{(--verbose-only) (Lit_Other '=') (Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:verbose_only spids:[1181])
                          op: Equal
                          rhs: 
                            {
                              (word_part.BracedVarSub
                                token: <VSub_Number 1>
                                suffix_op: (suffix_op.StringUnary op_id:VOp1_Pound arg_word:{('--*=')})
                                spids: [1182 1186]
                              )
                            }
                          spids: [1181]
                        )
                      ]
                      spids: [1181]
                    )
                    (C {(shift)})
                  ]
                  spids: [1175 1178 1191 16777215]
                )
                (case_arm
                  pat_list: [{(-q)} {(--q)} {(--qu)} {(--qui)} {(--quie)} {(--quiet)}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DAmp]
                          children: [
                            (C {(test)} {(-z)} {(DQ ($ VSub_Name '$HARNESS_ACTIVE'))})
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:quiet spids:[1226])
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1226]
                                )
                              ]
                              spids: [1226]
                            )
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                  ]
                  spids: [1194 1205 1232 16777215]
                )
                (case_arm
                  pat_list: [{(--with-dashes)}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:with_dashes spids:[1239])
                              op: Equal
                              rhs: {(t)}
                              spids: [1239]
                            )
                          ]
                          spids: [1239]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                  ]
                  spids: [1235 1236 1245 16777215]
                )
                (case_arm
                  pat_list: [{(--no-color)}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:color spids:[1252])
                              op: Equal
                              rhs: (word.EmptyWord)
                              spids: [1252]
                            )
                          ]
                          spids: [1252]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                  ]
                  spids: [1248 1249 1257 16777215]
                )
                (case_arm
                  pat_list: [
                    {(--va)}
                    {(--val)}
                    {(--valg)}
                    {(--valgr)}
                    {(--valgri)}
                    {(--valgrin)}
                    {(--valgrind)}
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:valgrind spids:[1276])
                          op: Equal
                          rhs: {(memcheck)}
                          spids: [1276]
                        )
                      ]
                      spids: [1276]
                    )
                    (C {(shift)})
                  ]
                  spids: [1260 1273 1282 16777215]
                )
                (case_arm
                  pat_list: [{(--valgrind) (Lit_Other '=') (Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:valgrind spids:[1291])
                          op: Equal
                          rhs: 
                            {
                              (word_part.BracedVarSub
                                token: <VSub_Number 1>
                                suffix_op: (suffix_op.StringUnary op_id:VOp1_Pound arg_word:{('--*=')})
                                spids: [1292 1296]
                              )
                            }
                          spids: [1291]
                        )
                      ]
                      spids: [1291]
                    )
                    (C {(shift)})
                  ]
                  spids: [1285 1288 1301 16777215]
                )
                (case_arm
                  pat_list: [{(--valgrind-only) (Lit_Other '=') (Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:valgrind_only spids:[1310])
                          op: Equal
                          rhs: 
                            {
                              (word_part.BracedVarSub
                                token: <VSub_Number 1>
                                suffix_op: (suffix_op.StringUnary op_id:VOp1_Pound arg_word:{('--*=')})
                                spids: [1311 1315]
                              )
                            }
                          spids: [1310]
                        )
                      ]
                      spids: [1310]
                    )
                    (C {(shift)})
                  ]
                  spids: [1304 1307 1320 16777215]
                )
                (case_arm
                  pat_list: [{(--tee)}]
                  action: [(C {(shift)})]
                  spids: [1323 1324 1329 16777215]
                )
                (case_arm
                  pat_list: [{(--root) (Lit_Other '=') (Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:root spids:[1341])
                          op: Equal
                          rhs: 
                            {
                              (word_part.BracedVarSub
                                token: <VSub_Number 1>
                                suffix_op: (suffix_op.StringUnary op_id:VOp1_Pound arg_word:{('--*=')})
                                spids: [1342 1346]
                              )
                            }
                          spids: [1341]
                        )
                      ]
                      spids: [1341]
                    )
                    (C {(shift)})
                  ]
                  spids: [1335 1338 1351 16777215]
                )
                (case_arm
                  pat_list: [{(--chain-lint)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:GIT_TEST_CHAIN_LINT spids:[1358])
                          op: Equal
                          rhs: {(1)}
                          spids: [1358]
                        )
                      ]
                      spids: [1358]
                    )
                    (C {(shift)})
                  ]
                  spids: [1354 1355 1364 16777215]
                )
                (case_arm
                  pat_list: [{(--no-chain-lint)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:GIT_TEST_CHAIN_LINT spids:[1371])
                          op: Equal
                          rhs: {(0)}
                          spids: [1371]
                        )
                      ]
                      spids: [1371]
                    )
                    (C {(shift)})
                  ]
                  spids: [1367 1368 1377 16777215]
                )
                (case_arm
                  pat_list: [{(-x)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:trace spids:[1384])
                          op: Equal
                          rhs: {(t)}
                          spids: [1384]
                        )
                      ]
                      spids: [1384]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:verbose spids:[1388])
                          op: Equal
                          rhs: {(t)}
                          spids: [1388]
                        )
                      ]
                      spids: [1388]
                    )
                    (C {(shift)})
                  ]
                  spids: [1380 1381 1394 16777215]
                )
                (case_arm
                  pat_list: [{(--verbose-log)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:verbose_log spids:[1401])
                          op: Equal
                          rhs: {(t)}
                          spids: [1401]
                        )
                      ]
                      spids: [1401]
                    )
                    (C {(shift)})
                  ]
                  spids: [1397 1398 1407 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.SimpleCommand
                          words: [
                            {(echo)}
                            {(DQ ("error: unknown test option '") ($ VSub_Number '$1') ("'"))}
                          ]
                          redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {(1)}
                    )
                  ]
                  spids: [1410 1411 1430 16777215]
                )
              ]
              spids: [956 962 1433]
            )
          ]
          spids: [953 1435]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$valgrind_only'))})]
          action: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name '$valgrind'))})
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:valgrind spids:[1461])
                      op: Equal
                      rhs: {(memcheck)}
                      spids: [1461]
                    )
                  ]
                  spids: [1461]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name '$verbose'))})
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:verbose_only spids:[1475])
                      op: Equal
                      rhs: {(DQ ($ VSub_Name '$valgrind_only'))}
                      spids: [1475]
                    )
                  ]
                  spids: [1475]
                )
              ]
            )
          ]
          spids: [16777215 1448]
        )
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$valgrind'))})]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:verbose spids:[1493])
                  op: Equal
                  rhs: {(t)}
                  spids: [1493]
                )
              ]
              spids: [1493]
            )
          ]
          spids: [1480 1490]
        )
      ]
      spids: [16777215 1496]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$color'))})]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:say_color_error spids:[1560])
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.Sentence
                                child: (C {(tput)} {(bold)})
                                terminator: <Op_Semi ';'>
                              )
                              (C {(tput)} {(setaf)} {(1)})
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1561 1572]
                      )
                    }
                  spids: [1560]
                )
              ]
              spids: [1560]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:say_color_skip spids:[1578])
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: (command.CommandList children:[(C {(tput)} {(setaf)} {(4)})])
                        left_token: <Left_CommandSub '$('>
                        spids: [1579 1585]
                      )
                    }
                  spids: [1578]
                )
              ]
              spids: [1578]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:say_color_warn spids:[1591])
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: (command.CommandList children:[(C {(tput)} {(setaf)} {(3)})])
                        left_token: <Left_CommandSub '$('>
                        spids: [1592 1598]
                      )
                    }
                  spids: [1591]
                )
              ]
              spids: [1591]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:say_color_pass spids:[1604])
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: (command.CommandList children:[(C {(tput)} {(setaf)} {(2)})])
                        left_token: <Left_CommandSub '$('>
                        spids: [1605 1611]
                      )
                    }
                  spids: [1604]
                )
              ]
              spids: [1604]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:say_color_info spids:[1617])
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: (command.CommandList children:[(C {(tput)} {(setaf)} {(6)})])
                        left_token: <Left_CommandSub '$('>
                        spids: [1618 1624]
                      )
                    }
                  spids: [1617]
                )
              ]
              spids: [1617]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:say_color_reset spids:[1630])
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: (command.CommandList children:[(C {(tput)} {(sgr0)})])
                        left_token: <Left_CommandSub '$('>
                        spids: [1631 1635]
                      )
                    }
                  spids: [1630]
                )
              ]
              spids: [1630]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:say_color_ spids:[1638])
                  op: Equal
                  rhs: {(DQ )}
                  spids: [1638]
                )
              ]
              spids: [1638]
            )
            (command.FuncDef
              name: say_color
              body: 
                (command.BraceGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DAmp Op_DAmp]
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Number '$1'))})
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$quiet'))})
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                        )
                      ]
                    )
                    (C {(eval)} 
                      {
                        (DQ ('say_color_color=') 
                          (word_part.EscapedLiteralPart
                            token: <Lit_EscapedChar '\\$'>
                          ) (say_color_) ($ VSub_Number '$1')
                        )
                      }
                    )
                    (C {(shift)})
                    (C {(printf)} 
                      {(DQ ('%s') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>) (n))} {(DQ ($ VSub_Name '$say_color_color') ($ VSub_Star '$*') ($ VSub_Name '$say_color_reset'))}
                    )
                  ]
                  spids: [1651]
                )
              spids: [1646 1650]
            )
          ]
          spids: [16777215 1509]
        )
      ]
      else_action: [
        (command.FuncDef
          name: say_color
          body: 
            (command.BraceGroup
              children: [
                (command.AndOr
                  ops: [Op_DAmp Op_DAmp]
                  children: [
                    (C {(test)} {(-z)} {(DQ ($ VSub_Number '$1'))})
                    (C {(test)} {(-n)} {(DQ ($ VSub_Name '$quiet'))})
                    (command.ControlFlow token:<ControlFlow_Return return>)
                  ]
                )
                (C {(shift)})
                (C {(printf)} {(DQ ('%s') (Lit_Other '\\') (n))} {(DQ ($ VSub_Star '$*'))})
              ]
              spids: [1714]
            )
          spids: [1710 1713]
        )
      ]
      spids: [1707 1758]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:TERM spids:[1761])
          op: Equal
          rhs: {(dumb)}
          spids: [1761]
        )
      ]
      spids: [1761]
    )
    (C {(export)} {(TERM)})
    (command.FuncDef
      name: error
      body: 
        (command.BraceGroup
          children: [
            (C {(say_color)} {(error)} {(DQ ('error: ') ($ VSub_Star '$*'))})
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:GIT_EXIT_OK spids:[1787])
                  op: Equal
                  rhs: {(t)}
                  spids: [1787]
                )
              ]
              spids: [1787]
            )
            (command.ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
          ]
          spids: [1774]
        )
      spids: [1769 1773]
    )
    (command.FuncDef
      name: say
      body: 
        (command.BraceGroup
          children: [(C {(say_color)} {(info)} {(DQ ($ VSub_Star '$*'))})]
          spids: [1803]
        )
      spids: [1798 1802]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$HARNESS_ACTIVE'))})]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {(DQ ($ VSub_Name '$verbose'))} {(Lit_Other '=')} {(t)})
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$verbose_only'))})
                      ]
                    )
                  ]
                  action: [
                    (C {(printf)} {(SQ <'Bail out! %s\\n'>)} 
                      {(SQ <'verbose mode forbidden under TAP harness; try --verbose-log'>)}
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {(1)}
                    )
                  ]
                  spids: [16777215 1853]
                )
              ]
              spids: [16777215 1874]
            )
          ]
          spids: [16777215 1827]
        )
      ]
      spids: [16777215 1876]
    )
    (command.AndOr
      ops: [Op_DPipe]
      children: [
        (C {(test)} {(DQ (${ VSub_Name test_description))} {(KW_Bang '!') (Lit_Other '=')} {(DQ )})
        (C {(error)} {(DQ ('Test script did not set test_description.'))})
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(DQ ($ VSub_Name '$help'))} {(Lit_Other '=')} {(DQ (t))})]
          action: [
            (C {(printf)} {(SQ <'%s\\n'>)} {(DQ ($ VSub_Name '$test_description'))})
            (command.ControlFlow token:<ControlFlow_Exit exit> arg_word:{(0)})
          ]
          spids: [16777215 1916]
        )
      ]
      spids: [16777215 1934]
    )
    (command.SimpleCommand
      words: [{(exec)}]
      redirects: [(redir.Redir op:<Redir_GreatAnd '5>&'> fd:5 arg_word:{(1)})]
    )
    (command.SimpleCommand
      words: [{(exec)}]
      redirects: [(redir.Redir op:<Redir_LessAnd '6<&'> fd:6 arg_word:{(0)})]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(DQ ($ VSub_Name '$verbose_log'))} {(Lit_Other '=')} {(DQ (t))})]
          action: [
            (command.SimpleCommand
              words: [{(exec)}]
              redirects: [
                (redir.Redir
                  op: <Redir_DGreat '3>>'>
                  fd: 3
                  arg_word: {(DQ ($ VSub_Name '$GIT_TEST_TEE_OUTPUT_FILE'))}
                )
                (redir.Redir op:<Redir_GreatAnd '4>&'> fd:4 arg_word:{(3)})
              ]
            )
          ]
          spids: [16777215 1961]
        )
        (if_arm
          cond: [(C {(test)} {(DQ ($ VSub_Name '$verbose'))} {(Lit_Other '=')} {(DQ (t))})]
          action: [
            (command.SimpleCommand
              words: [{(exec)}]
              redirects: [
                (redir.Redir op:<Redir_GreatAnd '4>&'> fd:4 arg_word:{(2)})
                (redir.Redir op:<Redir_GreatAnd '3>&'> fd:3 arg_word:{(1)})
              ]
            )
          ]
          spids: [1974 1988]
        )
      ]
      else_action: [
        (command.SimpleCommand
          words: [{(exec)}]
          redirects: [
            (redir.Redir op:<Redir_Great '4>'> fd:4 arg_word:{(/dev/null)})
            (redir.Redir op:<Redir_Great '3>'> fd:3 arg_word:{(/dev/null)})
          ]
        )
      ]
      spids: [1999 2010]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:BASH_XTRACEFD spids:[2046])
          op: Equal
          rhs: {(4)}
          spids: [2046]
        )
      ]
      spids: [2046]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:test_failure spids:[2050])
          op: Equal
          rhs: {(0)}
          spids: [2050]
        )
      ]
      spids: [2050]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:test_count spids:[2053])
          op: Equal
          rhs: {(0)}
          spids: [2053]
        )
      ]
      spids: [2053]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:test_fixed spids:[2056])
          op: Equal
          rhs: {(0)}
          spids: [2056]
        )
      ]
      spids: [2056]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:test_broken spids:[2059])
          op: Equal
          rhs: {(0)}
          spids: [2059]
        )
      ]
      spids: [2059]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:test_success spids:[2062])
          op: Equal
          rhs: {(0)}
          spids: [2062]
        )
      ]
      spids: [2062]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:test_external_has_tap spids:[2066])
          op: Equal
          rhs: {(0)}
          spids: [2066]
        )
      ]
      spids: [2066]
    )
    (command.FuncDef
      name: die
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:code spids:[2078])
                  op: Equal
                  rhs: {($ VSub_QMark '$?')}
                  spids: [2078]
                )
              ]
              spids: [2078]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$GIT_EXIT_OK'))})]
                  action: [
                    (command.ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {($ VSub_Name '$code')}
                    )
                  ]
                  spids: [16777215 2093]
                )
              ]
              else_action: [
                (command.SimpleCommand
                  words: [{(echo)} {(DQ ('FATAL: Unexpected exit with code ') ($ VSub_Name '$code'))}]
                  redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(5)})]
                )
                (command.ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
              ]
              spids: [2101 2120]
            )
          ]
          spids: [2075]
        )
      spids: [2070 2074]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:GIT_EXIT_OK spids:[2125])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [2125]
        )
      ]
      spids: [2125]
    )
    (C {(trap)} {(SQ <die>)} {(EXIT)})
    (C {(trap)} {(SQ <'exit $?'>)} {(INT)})
    (C {(.)} {(DQ ($ VSub_Name '$TEST_DIRECTORY') (/test-lib-functions.sh))})
    (command.FuncDef
      name: test_ok_
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:test_success spids:[2173])
                  op: Equal
                  rhs: 
                    {
                      (word_part.ArithSubPart
                        anode: 
                          (arith_expr.ArithBinary
                            op_id: Arith_Plus
                            left: (arith_expr.ArithWord w:{($ VSub_Name '$test_success')})
                            right: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                          )
                        spids: [2174 2181]
                      )
                    }
                  spids: [2173]
                )
              ]
              spids: [2173]
            )
            (C {(say_color)} {(DQ )} {(DQ ('ok ') ($ VSub_Name '$test_count') (' - ') ($ VSub_At '$@'))})
          ]
          spids: [2170]
        )
      spids: [2165 2169]
    )
    (command.FuncDef
      name: test_failure_
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:test_failure spids:[2207])
                  op: Equal
                  rhs: 
                    {
                      (word_part.ArithSubPart
                        anode: 
                          (arith_expr.ArithBinary
                            op_id: Arith_Plus
                            left: (arith_expr.ArithWord w:{($ VSub_Name '$test_failure')})
                            right: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                          )
                        spids: [2208 2215]
                      )
                    }
                  spids: [2207]
                )
              ]
              spids: [2207]
            )
            (C {(say_color)} {(error)} 
              {(DQ ('not ok ') ($ VSub_Name '$test_count') (' - ') ($ VSub_Number '$1'))}
            )
            (C {(shift)})
            (command.Pipeline
              children: [
                (C {(printf)} {(SQ <'%s\\n'>)} {(DQ ($ VSub_Star '$*'))})
                (C {(sed)} {(-e)} {(SQ <'s/^/#\t/'>)})
              ]
              negated: F
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(DQ ($ VSub_Name '$immediate'))} {(Lit_Other '=')} {(DQ )})
                (command.BraceGroup
                  children: [
                    (command.Sentence
                      child: 
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:GIT_EXIT_OK spids:[2269])
                              op: Equal
                              rhs: {(t)}
                              spids: [2269]
                            )
                          ]
                          spids: [2269]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (command.Sentence
                      child: (command.ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  spids: [2267]
                )
              ]
            )
          ]
          spids: [2204]
        )
      spids: [2199 2203]
    )
    (command.FuncDef
      name: test_known_broken_ok_
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:test_fixed spids:[2291])
                  op: Equal
                  rhs: 
                    {
                      (word_part.ArithSubPart
                        anode: 
                          (arith_expr.ArithBinary
                            op_id: Arith_Plus
                            left: (arith_expr.ArithWord w:{($ VSub_Name '$test_fixed')})
                            right: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                          )
                        spids: [2292 2297]
                      )
                    }
                  spids: [2291]
                )
              ]
              spids: [2291]
            )
            (C {(say_color)} {(error)} 
              {
                (DQ ('ok ') ($ VSub_Name '$test_count') (' - ') ($ VSub_At '$@') 
                  (' # TODO known breakage vanished')
                )
              }
            )
          ]
          spids: [2288]
        )
      spids: [2283 2287]
    )
    (command.FuncDef
      name: test_known_broken_failure_
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:test_broken spids:[2323])
                  op: Equal
                  rhs: 
                    {
                      (word_part.ArithSubPart
                        anode: 
                          (arith_expr.ArithBinary
                            op_id: Arith_Plus
                            left: (arith_expr.ArithWord w:{($ VSub_Name '$test_broken')})
                            right: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                          )
                        spids: [2324 2329]
                      )
                    }
                  spids: [2323]
                )
              ]
              spids: [2323]
            )
            (C {(say_color)} {(warn)} 
              {
                (DQ ('not ok ') ($ VSub_Name '$test_count') (' - ') ($ VSub_At '$@') 
                  (' # TODO known breakage')
                )
              }
            )
          ]
          spids: [2320]
        )
      spids: [2315 2319]
    )
    (command.FuncDef
      name: test_debug
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(DQ ($ VSub_Name '$debug'))} {(Lit_Other '=')} {(DQ )})
                (C {(eval)} {(DQ ($ VSub_Number '$1'))})
              ]
            )
          ]
          spids: [2352]
        )
      spids: [2347 2351]
    )
    (command.FuncDef
      name: match_pattern_list
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:arg spids:[2385])
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$1'))}
                  spids: [2385]
                )
              ]
              spids: [2385]
            )
            (C {(shift)})
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Star '$*'))})
                (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
            )
            (command.ForEach
              iter_name: pattern_
              do_arg_iter: T
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ VSub_Name '$arg'))}
                      arms: [
                        (case_arm
                          pat_list: [{($ VSub_Name '$pattern_')}]
                          action: [
                            (command.ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                          spids: [2426 2427 16777215 2435]
                        )
                      ]
                      spids: [2417 2423 2435]
                    )
                  ]
                  spids: [2414 2438]
                )
              spids: [16777215 16777215]
            )
            (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
          spids: [2382]
        )
      spids: [2377 2381]
    )
    (command.FuncDef
      name: match_test_selector_list
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:title spids:[2456])
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$1'))}
                  spids: [2456]
                )
              ]
              spids: [2456]
            )
            (C {(shift)})
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:arg spids:[2465])
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$1'))}
                  spids: [2465]
                )
              ]
              spids: [2465]
            )
            (C {(shift)})
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Number '$1'))})
                (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:OLDIFS spids:[2494])
                  op: Equal
                  rhs: {($ VSub_Name '$IFS')}
                  spids: [2494]
                )
              ]
              spids: [2494]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:IFS spids:[2498])
                  op: Equal
                  rhs: {(SQ <' \t,'>)}
                  spids: [2498]
                )
              ]
              spids: [2498]
            )
            (C {(set)} {(--)} {($ VSub_Number '$1')})
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:IFS spids:[2511])
                  op: Equal
                  rhs: {($ VSub_Name '$OLDIFS')}
                  spids: [2511]
                )
              ]
              spids: [2511]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:include spids:[2520])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [2520]
                )
              ]
              spids: [2520]
            )
            (command.Case
              to_match: {(DQ ($ VSub_Number '$1'))}
              arms: [
                (case_arm
                  pat_list: [{(KW_Bang '!') (Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:include spids:[2536])
                          op: Equal
                          rhs: {(t)}
                          spids: [2536]
                        )
                      ]
                      spids: [2536]
                    )
                  ]
                  spids: [2532 2534 2539 16777215]
                )
              ]
              spids: [2523 2529 2542]
            )
            (command.ForEach
              iter_name: selector
              do_arg_iter: T
              body: 
                (command.DoGroup
                  children: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:orig_selector spids:[2554])
                          op: Equal
                          rhs: {($ VSub_Name '$selector')}
                          spids: [2554]
                        )
                      ]
                      spids: [2554]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:positive spids:[2559])
                          op: Equal
                          rhs: {(t)}
                          spids: [2559]
                        )
                      ]
                      spids: [2559]
                    )
                    (command.Case
                      to_match: {(DQ ($ VSub_Name '$selector'))}
                      arms: [
                        (case_arm
                          pat_list: [{(KW_Bang '!') (Lit_Other '*')}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:positive spids:[2577])
                                  op: Equal
                                  rhs: (word.EmptyWord)
                                  spids: [2577]
                                )
                              ]
                              spids: [2577]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:selector spids:[2580])
                                  op: Equal
                                  rhs: 
                                    {
                                      (word_part.BracedVarSub
                                        token: <VSub_Name selector>
                                        suffix_op: 
                                          (suffix_op.StringUnary
                                            op_id: VOp1_DPound
                                            arg_word: {('?')}
                                          )
                                        spids: [2581 2585]
                                      )
                                    }
                                  spids: [2580]
                                )
                              ]
                              spids: [2580]
                            )
                          ]
                          spids: [2572 2574 2588 16777215]
                        )
                      ]
                      spids: [2563 2569 2591]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name '$selector'))})
                        (command.ControlFlow
                          token: <ControlFlow_Continue continue>
                        )
                      ]
                    )
                    (command.Case
                      to_match: {(DQ ($ VSub_Name '$selector'))}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Other '*') (-) (Lit_Other '*')}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.SimpleCommand
                                      words: [
                                        {(expr)}
                                        {
                                          (DQ (z) 
                                            (word_part.BracedVarSub
                                              token: <VSub_Name selector>
                                              suffix_op: 
                                                (suffix_op.StringUnary
                                                  op_id: VOp1_DPercent
                                                  arg_word: {('-*')}
                                                )
                                              spids: [2630 2634]
                                            )
                                          )
                                        }
                                        {(Lit_Other ':')}
                                        {(DQ ('z[0-9]*[^0-9]'))}
                                      ]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_Great '>'>
                                          fd: 16777215
                                          arg_word: {(/dev/null)}
                                        )
                                      ]
                                    )
                                  ]
                                  action: [
                                    (command.SimpleCommand
                                      words: [
                                        {(echo)}
                                        {
                                          (DQ ('error: ') ($ VSub_Name '$title') 
                                            (': invalid non-numeric in range')
                                          )
                                        }
                                        {(DQ ("start: '") ($ VSub_Name '$orig_selector') ("'"))}
                                      ]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_GreatAnd '>&'>
                                          fd: 16777215
                                          arg_word: {(2)}
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Exit exit>
                                      arg_word: {(1)}
                                    )
                                  ]
                                  spids: [16777215 2647]
                                )
                              ]
                              spids: [16777215 2675]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.SimpleCommand
                                      words: [
                                        {(expr)}
                                        {
                                          (DQ (z) 
                                            (word_part.BracedVarSub
                                              token: <VSub_Name selector>
                                              suffix_op: 
                                                (suffix_op.StringUnary
                                                  op_id: VOp1_Pound
                                                  arg_word: {('*-')}
                                                )
                                              spids: [2684 2688]
                                            )
                                          )
                                        }
                                        {(Lit_Other ':')}
                                        {(DQ ('z[0-9]*[^0-9]'))}
                                      ]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_Great '>'>
                                          fd: 16777215
                                          arg_word: {(/dev/null)}
                                        )
                                      ]
                                    )
                                  ]
                                  action: [
                                    (command.SimpleCommand
                                      words: [
                                        {(echo)}
                                        {
                                          (DQ ('error: ') ($ VSub_Name '$title') 
                                            (': invalid non-numeric in range')
                                          )
                                        }
                                        {(DQ ("end: '") ($ VSub_Name '$orig_selector') ("'"))}
                                      ]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_GreatAnd '>&'>
                                          fd: 16777215
                                          arg_word: {(2)}
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Exit exit>
                                      arg_word: {(1)}
                                    )
                                  ]
                                  spids: [16777215 2701]
                                )
                              ]
                              spids: [16777215 2729]
                            )
                          ]
                          spids: [2618 2621 2732 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.SimpleCommand
                                      words: [
                                        {(expr)}
                                        {(DQ (z) ($ VSub_Name '$selector'))}
                                        {(Lit_Other ':')}
                                        {(DQ ('z[0-9]*[^0-9]'))}
                                      ]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_Great '>'>
                                          fd: 16777215
                                          arg_word: {(/dev/null)}
                                        )
                                      ]
                                    )
                                  ]
                                  action: [
                                    (command.SimpleCommand
                                      words: [
                                        {(echo)}
                                        {
                                          (DQ ('error: ') ($ VSub_Name '$title') 
                                            (': invalid non-numeric in test')
                                          )
                                        }
                                        {(DQ ("selector: '") ($ VSub_Name '$orig_selector') ("'"))}
                                      ]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_GreatAnd '>&'>
                                          fd: 16777215
                                          arg_word: {(2)}
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Exit exit>
                                      arg_word: {(1)}
                                    )
                                  ]
                                  spids: [16777215 2758]
                                )
                              ]
                              spids: [16777215 2786]
                            )
                          ]
                          spids: [2735 2736 16777215 2789]
                        )
                      ]
                      spids: [2609 2615 2789]
                    )
                    (command.AndOr
                      ops: [Op_DAmp Op_DAmp]
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name '$include'))})
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name '$positive'))})
                        (command.ControlFlow
                          token: <ControlFlow_Continue continue>
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DAmp Op_DAmp]
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$include'))})
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$positive'))})
                        (command.ControlFlow
                          token: <ControlFlow_Continue continue>
                        )
                      ]
                    )
                    (command.Case
                      to_match: {(DQ ($ VSub_Name '$selector'))}
                      arms: [
                        (case_arm
                          pat_list: [{(-) (Lit_Other '*')}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (C {(test)} {($ VSub_Name '$arg')} {(-le)} 
                                      {
                                        (word_part.BracedVarSub
                                          token: <VSub_Name selector>
                                          suffix_op: 
                                            (suffix_op.StringUnary
                                              op_id: VOp1_Pound
                                              arg_word: {(-)}
                                            )
                                          spids: [2866 2870]
                                        )
                                      }
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:include spids:[2876])
                                          op: Equal
                                          rhs: {($ VSub_Name '$positive')}
                                          spids: [2876]
                                        )
                                      ]
                                      spids: [2876]
                                    )
                                  ]
                                  spids: [16777215 2873]
                                )
                              ]
                              spids: [16777215 2880]
                            )
                          ]
                          spids: [2853 2855 2883 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*') (-)}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (C {(test)} {($ VSub_Name '$arg')} {(-ge)} 
                                      {
                                        (word_part.BracedVarSub
                                          token: <VSub_Name selector>
                                          suffix_op: 
                                            (suffix_op.StringUnary
                                              op_id: VOp1_Percent
                                              arg_word: {(-)}
                                            )
                                          spids: [2899 2903]
                                        )
                                      }
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:include spids:[2909])
                                          op: Equal
                                          rhs: {($ VSub_Name '$positive')}
                                          spids: [2909]
                                        )
                                      ]
                                      spids: [2909]
                                    )
                                  ]
                                  spids: [16777215 2906]
                                )
                              ]
                              spids: [16777215 2913]
                            )
                          ]
                          spids: [2886 2888 2916 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*') (-) (Lit_Other '*')}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} 
                                          {
                                            (word_part.BracedVarSub
                                              token: <VSub_Name selector>
                                              suffix_op: 
                                                (suffix_op.StringUnary
                                                  op_id: VOp1_DPercent
                                                  arg_word: {('-*')}
                                                )
                                              spids: [2929 2933]
                                            )
                                          } {(-le)} {($ VSub_Name '$arg')}
                                        )
                                        (C {(test)} {($ VSub_Name '$arg')} {(-le)} 
                                          {
                                            (word_part.BracedVarSub
                                              token: <VSub_Name selector>
                                              suffix_op: 
                                                (suffix_op.StringUnary
                                                  op_id: VOp1_Pound
                                                  arg_word: {('*-')}
                                                )
                                              spids: [2949 2953]
                                            )
                                          }
                                        )
                                      ]
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:include spids:[2959])
                                          op: Equal
                                          rhs: {($ VSub_Name '$positive')}
                                          spids: [2959]
                                        )
                                      ]
                                      spids: [2959]
                                    )
                                  ]
                                  spids: [16777215 2956]
                                )
                              ]
                              spids: [16777215 2963]
                            )
                          ]
                          spids: [2919 2922 2966 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (C {(test)} {($ VSub_Name '$arg')} {(-eq)} 
                                      {($ VSub_Name '$selector')}
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:include spids:[2987])
                                          op: Equal
                                          rhs: {($ VSub_Name '$positive')}
                                          spids: [2987]
                                        )
                                      ]
                                      spids: [2987]
                                    )
                                  ]
                                  spids: [16777215 2984]
                                )
                              ]
                              spids: [16777215 2991]
                            )
                          ]
                          spids: [2969 2970 2994 16777215]
                        )
                      ]
                      spids: [2844 2850 2997]
                    )
                  ]
                  spids: [2551 3000]
                )
              spids: [16777215 16777215]
            )
            (C {(test)} {(-n)} {(DQ ($ VSub_Name '$include'))})
          ]
          spids: [2453]
        )
      spids: [2448 2452]
    )
    (command.FuncDef
      name: maybe_teardown_verbose
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name '$verbose_only'))})
                (command.ControlFlow token:<ControlFlow_Return return>)
              ]
            )
            (command.SimpleCommand
              words: [{(exec)}]
              redirects: [
                (redir.Redir op:<Redir_Great '4>'> fd:4 arg_word:{(/dev/null)})
                (redir.Redir op:<Redir_Great '3>'> fd:3 arg_word:{(/dev/null)})
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:verbose spids:[3045])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [3045]
                )
              ]
              spids: [3045]
            )
          ]
          spids: [3020]
        )
      spids: [3015 3019]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:last_verbose spids:[3050])
          op: Equal
          rhs: {(t)}
          spids: [3050]
        )
      ]
      spids: [3050]
    )
    (command.FuncDef
      name: maybe_setup_verbose
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name '$verbose_only'))})
                (command.ControlFlow token:<ControlFlow_Return return>)
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {(match_pattern_list)} {($ VSub_Name '$test_count')} 
                      {($ VSub_Name '$verbose_only')}
                    )
                  ]
                  action: [
                    (command.SimpleCommand
                      words: [{(exec)}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_GreatAnd '4>&'>
                          fd: 4
                          arg_word: {(2)}
                        )
                        (redir.Redir
                          op: <Redir_GreatAnd '3>&'>
                          fd: 3
                          arg_word: {(1)}
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name '$last_verbose'))})
                        (command.SimpleCommand
                          words: [{(echo)} {(DQ )}]
                          redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(3)})]
                        )
                      ]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:verbose spids:[3134])
                          op: Equal
                          rhs: {(t)}
                          spids: [3134]
                        )
                      ]
                      spids: [3134]
                    )
                  ]
                  spids: [16777215 3083]
                )
              ]
              else_action: [
                (command.SimpleCommand
                  words: [{(exec)}]
                  redirects: [
                    (redir.Redir op:<Redir_Great '4>'> fd:4 arg_word:{(/dev/null)})
                    (redir.Redir op:<Redir_Great '3>'> fd:3 arg_word:{(/dev/null)})
                  ]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:verbose spids:[3150])
                      op: Equal
                      rhs: (word.EmptyWord)
                      spids: [3150]
                    )
                  ]
                  spids: [3150]
                )
              ]
              spids: [3138 3153]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:last_verbose spids:[3156])
                  op: Equal
                  rhs: {($ VSub_Name '$verbose')}
                  spids: [3156]
                )
              ]
              spids: [3156]
            )
          ]
          spids: [3058]
        )
      spids: [3053 3057]
    )
    (command.FuncDef
      name: maybe_teardown_valgrind
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name '$GIT_VALGRIND'))})
                (command.ControlFlow token:<ControlFlow_Return return>)
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:GIT_VALGRIND_ENABLED spids:[3183])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [3183]
                )
              ]
              spids: [3183]
            )
          ]
          spids: [3167]
        )
      spids: [3162 3166]
    )
    (command.FuncDef
      name: maybe_setup_valgrind
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name '$GIT_VALGRIND'))})
                (command.ControlFlow token:<ControlFlow_Return return>)
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$valgrind_only'))})]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:GIT_VALGRIND_ENABLED spids:[3223])
                          op: Equal
                          rhs: {(t)}
                          spids: [3223]
                        )
                      ]
                      spids: [3223]
                    )
                    (command.ControlFlow token:<ControlFlow_Return return>)
                  ]
                  spids: [16777215 3220]
                )
              ]
              spids: [16777215 3230]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:GIT_VALGRIND_ENABLED spids:[3233])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [3233]
                )
              ]
              spids: [3233]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {(match_pattern_list)} {($ VSub_Name '$test_count')} 
                      {($ VSub_Name '$valgrind_only')}
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:GIT_VALGRIND_ENABLED spids:[3248])
                          op: Equal
                          rhs: {(t)}
                          spids: [3248]
                        )
                      ]
                      spids: [3248]
                    )
                  ]
                  spids: [16777215 3245]
                )
              ]
              spids: [16777215 3252]
            )
          ]
          spids: [3193]
        )
      spids: [3188 3192]
    )
    (command.FuncDef
      name: want_trace
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(DQ ($ VSub_Name '$trace'))} {(Lit_Other '=')} {(t)})
                (C {(test)} {(DQ ($ VSub_Name '$verbose'))} {(Lit_Other '=')} {(t)})
              ]
            )
          ]
          spids: [3262]
        )
      spids: [3257 3261]
    )
    (command.FuncDef
      name: test_eval_inner_
      body: 
        (command.BraceGroup
          children: [
            (C {(eval)} {(DQ ('\n') ('\t\twant_trace && set -x\n') ('\t\t') ($ VSub_Star '$*'))})
          ]
          spids: [3307]
        )
      spids: [3302 3306]
    )
    (command.FuncDef
      name: test_eval_
      body: 
        (command.BraceGroup
          children: [
            (command.BraceGroup
              children: [
                (command.SimpleCommand
                  words: [{(test_eval_inner_)} {(DQ ($ VSub_At '$@'))}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Less '<'>
                      fd: 16777215
                      arg_word: {(/dev/null)}
                    )
                    (redir.Redir
                      op: <Redir_GreatAnd '>&'>
                      fd: 16777215
                      arg_word: {(3)}
                    )
                    (redir.Redir op:<Redir_GreatAnd '2>&'> fd:2 arg_word:{(4)})
                  ]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:test_eval_ret_ spids:[3385])
                      op: Equal
                      rhs: {($ VSub_QMark '$?')}
                      spids: [3385]
                    )
                  ]
                  spids: [3385]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: [(C {(want_trace)})]
                      action: [
                        (C {(set)} {(Lit_Other '+') (x)})
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (C {(test)} {(DQ ($ VSub_Name '$test_eval_ret_'))} 
                                  {(KW_Bang '!') (Lit_Other '=')} {(0)}
                                )
                              ]
                              action: [
                                (command.SimpleCommand
                                  words: [
                                    {(say_color)}
                                    {(error)}
                                    {
                                      (DQ ('error: last command exited with ') 
                                        (word_part.EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        ) ('?=') ($ VSub_Name '$test_eval_ret_')
                                      )
                                    }
                                  ]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_GreatAnd '>&'>
                                      fd: 16777215
                                      arg_word: {(4)}
                                    )
                                  ]
                                )
                              ]
                              spids: [16777215 3417]
                            )
                          ]
                          spids: [16777215 3435]
                        )
                      ]
                      spids: [16777215 3394]
                    )
                  ]
                  spids: [16777215 3438]
                )
              ]
              redirects: [(redir.Redir op:<Redir_Great '2>'> fd:2 arg_word:{(/dev/null)})]
              spids: [3366]
            )
            (command.ControlFlow
              token: <ControlFlow_Return return>
              arg_word: {($ VSub_Name '$test_eval_ret_')}
            )
          ]
          spids: [3331]
        )
      spids: [3326 3330]
    )
    (command.FuncDef
      name: test_run_
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:test_cleanup spids:[3462])
                  op: Equal
                  rhs: {(Lit_Other ':')}
                  spids: [3462]
                )
              ]
              spids: [3462]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:expecting_failure spids:[3466])
                  op: Equal
                  rhs: {($ VSub_Number '$2')}
                  spids: [3466]
                )
              ]
              spids: [3466]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(test)} 
                          {
                            (DQ 
                              (word_part.BracedVarSub
                                token: <VSub_Name GIT_TEST_CHAIN_LINT>
                                suffix_op: 
                                  (suffix_op.StringUnary
                                    op_id: VTest_ColonHyphen
                                    arg_word: {(1)}
                                  )
                                spids: [3476 3480]
                              )
                            )
                          } {(KW_Bang '!') (Lit_Other '=')} {(0)}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:trace_tmp spids:[3500])
                          op: Equal
                          rhs: {($ VSub_Name '$trace')}
                          spids: [3500]
                        )
                      ]
                      spids: [3500]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:trace spids:[3504])
                          op: Equal
                          rhs: (word.EmptyWord)
                          spids: [3504]
                        )
                      ]
                      spids: [3504]
                    )
                    (C {(test_eval_)} {(DQ ('(exit 117) && ') ($ VSub_Number '$1'))})
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(test)} {(DQ ($ VSub_QMark '$?'))} {(KW_Bang '!') (Lit_Other '=')} 
                                  {(117)}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(error)} 
                              {
                                (DQ ('bug in the test script: broken &&-chain: ') ($ VSub_Number '$1'))
                              }
                            )
                          ]
                          spids: [16777215 3537]
                        )
                      ]
                      spids: [16777215 3548]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:trace spids:[3551])
                          op: Equal
                          rhs: {($ VSub_Name '$trace_tmp')}
                          spids: [3551]
                        )
                      ]
                      spids: [3551]
                    )
                  ]
                  spids: [16777215 3489]
                )
              ]
              spids: [16777215 3555]
            )
            (C {(setup_malloc_check)})
            (C {(test_eval_)} {(DQ ($ VSub_Number '$1'))})
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:eval_ret spids:[3569])
                  op: Equal
                  rhs: {($ VSub_QMark '$?')}
                  spids: [3569]
                )
              ]
              spids: [3569]
            )
            (C {(teardown_malloc_check)})
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Op_DPipe Op_DPipe Op_DAmp]
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name '$immediate'))})
                        (C {(test)} {($ VSub_Name '$eval_ret')} {(Lit_Other '=')} {(0)})
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$expecting_failure'))})
                        (C {(test)} {(DQ ($ VSub_Name '$test_cleanup'))} {(KW_Bang '!') (Lit_Other '=')} 
                          {(DQ (':'))}
                        )
                      ]
                    )
                  ]
                  action: [
                    (C {(setup_malloc_check)})
                    (C {(test_eval_)} {(DQ ($ VSub_Name '$test_cleanup'))})
                    (C {(teardown_malloc_check)})
                  ]
                  spids: [16777215 3624]
                )
              ]
              spids: [16777215 3640]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(DQ ($ VSub_Name '$verbose'))} {(Lit_Other '=')} {(DQ (t))})
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$HARNESS_ACTIVE'))})
                      ]
                    )
                  ]
                  action: [(C {(echo)} {(DQ )})]
                  spids: [16777215 3668]
                )
              ]
              spids: [16777215 3677]
            )
            (command.ControlFlow
              token: <ControlFlow_Return return>
              arg_word: {(DQ ($ VSub_Name '$eval_ret'))}
            )
          ]
          spids: [3459]
        )
      spids: [3454 3458]
    )
    (command.FuncDef
      name: test_start_
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:test_count spids:[3697])
                  op: Equal
                  rhs: 
                    {
                      (word_part.ArithSubPart
                        anode: 
                          (arith_expr.ArithBinary
                            op_id: Arith_Plus
                            left: (arith_expr.ArithWord w:{($ VSub_Name '$test_count')})
                            right: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                          )
                        spids: [3698 3703]
                      )
                    }
                  spids: [3697]
                )
              ]
              spids: [3697]
            )
            (C {(maybe_setup_verbose)})
            (C {(maybe_setup_valgrind)})
          ]
          spids: [3694]
        )
      spids: [3689 3693]
    )
    (command.FuncDef
      name: test_finish_
      body: 
        (command.BraceGroup
          children: [
            (command.SimpleCommand
              words: [{(echo)} {(DQ )}]
              redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(3)})]
            )
            (C {(maybe_teardown_valgrind)})
            (C {(maybe_teardown_verbose)})
          ]
          spids: [3719]
        )
      spids: [3714 3718]
    )
    (command.FuncDef
      name: test_skip
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:to_skip spids:[3747])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [3747]
                )
              ]
              spids: [3747]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:skipped_reason spids:[3750])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [3750]
                )
              ]
              spids: [3750]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {(match_pattern_list)} 
                      {($ VSub_Name '$this_test') (.) ($ VSub_Name '$test_count')} {($ VSub_Name '$GIT_SKIP_TESTS')}
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:to_skip spids:[3767])
                          op: Equal
                          rhs: {(t)}
                          spids: [3767]
                        )
                      ]
                      spids: [3767]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:skipped_reason spids:[3771])
                          op: Equal
                          rhs: {(DQ (GIT_SKIP_TESTS))}
                          spids: [3771]
                        )
                      ]
                      spids: [3771]
                    )
                  ]
                  spids: [16777215 3764]
                )
              ]
              spids: [16777215 3777]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Op_DAmp Op_DAmp]
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name '$to_skip'))})
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$test_prereq'))})
                        (command.Pipeline
                          children: [(C {(test_have_prereq)} {(DQ ($ VSub_Name '$test_prereq'))})]
                          negated: T
                        )
                      ]
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:to_skip spids:[3815])
                          op: Equal
                          rhs: {(t)}
                          spids: [3815]
                        )
                      ]
                      spids: [3815]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:of_prereq spids:[3820])
                          op: Equal
                          rhs: (word.EmptyWord)
                          spids: [3820]
                        )
                      ]
                      spids: [3820]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(test)} {(DQ ($ VSub_Name '$missing_prereq'))} 
                              {(KW_Bang '!') (Lit_Other '=')} {(DQ ($ VSub_Name '$test_prereq'))}
                            )
                          ]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:of_prereq spids:[3842])
                                  op: Equal
                                  rhs: {(DQ (' of ') ($ VSub_Name '$test_prereq'))}
                                  spids: [3842]
                                )
                              ]
                              spids: [3842]
                            )
                          ]
                          spids: [16777215 3839]
                        )
                      ]
                      spids: [16777215 3849]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:skipped_reason spids:[3852])
                          op: Equal
                          rhs: 
                            {
                              (DQ ('missing ') ($ VSub_Name '$missing_prereq') (${ VSub_Name of_prereq))
                            }
                          spids: [3852]
                        )
                      ]
                      spids: [3852]
                    )
                  ]
                  spids: [16777215 3812]
                )
              ]
              spids: [16777215 3862]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Op_DAmp Op_DAmp]
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name '$to_skip'))})
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$run_list'))})
                        (command.Pipeline
                          children: [
                            (C {(match_test_selector_list)} {(SQ <--run>)} {($ VSub_Name '$test_count')} 
                              {(DQ ($ VSub_Name '$run_list'))}
                            )
                          ]
                          negated: T
                        )
                      ]
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:to_skip spids:[3906])
                          op: Equal
                          rhs: {(t)}
                          spids: [3906]
                        )
                      ]
                      spids: [3906]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:skipped_reason spids:[3910])
                          op: Equal
                          rhs: {(DQ (--run))}
                          spids: [3910]
                        )
                      ]
                      spids: [3910]
                    )
                  ]
                  spids: [16777215 3903]
                )
              ]
              spids: [16777215 3916]
            )
            (command.Case
              to_match: {(DQ ($ VSub_Name '$to_skip'))}
              arms: [
                (case_arm
                  pat_list: [{(t)}]
                  action: [
                    (command.SimpleCommand
                      words: [{(say_color)} {(skip)} {(DQ ('skipping test: ') ($ VSub_At '$@'))}]
                      redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(3)})]
                    )
                    (C {(say_color)} {(skip)} 
                      {
                        (DQ ('ok ') ($ VSub_Name '$test_count') (' # skip ') ($ VSub_Number '$1') (' (') 
                          ($ VSub_Name '$skipped_reason') (')')
                        )
                      }
                    )
                    (C {(Lit_Other ':')} {(true)})
                  ]
                  spids: [3929 3930 3966 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [(C {(false)})]
                  spids: [3969 3970 3976 16777215]
                )
              ]
              spids: [3920 3926 3979]
            )
          ]
          spids: [3744]
        )
      spids: [3739 3743]
    )
    (command.FuncDef
      name: test_at_end_hook_
      body: (command.BraceGroup children:[(C {(Lit_Other ':')})] spids:[3992])
      spids: [3987 3991]
    )
    (command.FuncDef
      name: test_done
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:GIT_EXIT_OK spids:[4008])
                  op: Equal
                  rhs: {(t)}
                  spids: [4008]
                )
              ]
              spids: [4008]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$HARNESS_ACTIVE'))})]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:test_results_dir spids:[4027])
                          op: Equal
                          rhs: {(DQ ($ VSub_Name '$TEST_OUTPUT_DIRECTORY') (/test-results))}
                          spids: [4027]
                        )
                      ]
                      spids: [4027]
                    )
                    (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name '$test_results_dir'))})
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:base spids:[4043])
                          op: Equal
                          rhs: 
                            {
                              (word_part.BracedVarSub
                                token: <VSub_Number 0>
                                suffix_op: 
                                  (suffix_op.StringUnary
                                    op_id: VOp1_DPound
                                    arg_word: {('*') (Lit_Slash /)}
                                  )
                                spids: [4044 4049]
                              )
                            }
                          spids: [4043]
                        )
                      ]
                      spids: [4043]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:test_results_path spids:[4052])
                          op: Equal
                          rhs: 
                            {
                              (DQ ($ VSub_Name '$test_results_dir') (/) 
                                (word_part.BracedVarSub
                                  token: <VSub_Name base>
                                  suffix_op: 
                                    (suffix_op.StringUnary
                                      op_id: VOp1_Percent
                                      arg_word: {(.sh)}
                                    )
                                  spids: [4056 4060]
                                ) (.counts)
                              )
                            }
                          spids: [4052]
                        )
                      ]
                      spids: [4052]
                    )
                    (command.SimpleCommand
                      words: [{(cat)}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$test_results_path'))}
                        )
                        (redir.HereDoc
                          op: <Redir_DLessDash '<<-'>
                          fd: 16777215
                          here_begin: {(EOF)}
                          here_end_span_id: 4093
                          stdin_parts: [
                            ('total ')
                            ($ VSub_Name '$test_count')
                            ('\n')
                            ('success ')
                            ($ VSub_Name '$test_success')
                            ('\n')
                            ('fixed ')
                            ($ VSub_Name '$test_fixed')
                            ('\n')
                            ('broken ')
                            ($ VSub_Name '$test_broken')
                            ('\n')
                            ('failed ')
                            ($ VSub_Name '$test_failure')
                            ('\n')
                            ('\n')
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [16777215 4024]
                )
              ]
              spids: [16777215 4095]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} {(DQ ($ VSub_Name '$test_fixed'))} {(KW_Bang '!') (Lit_Other '=')} {(0)})
                  ]
                  action: [
                    (C {(say_color)} {(error)} 
                      {
                        (DQ ('# ') ($ VSub_Name '$test_fixed') 
                          (' known breakage(s) vanished; please update test(s)')
                        )
                      }
                    )
                  ]
                  spids: [16777215 4113]
                )
              ]
              spids: [16777215 4127]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} {(DQ ($ VSub_Name '$test_broken'))} {(KW_Bang '!') (Lit_Other '=')} {(0)})
                  ]
                  action: [
                    (C {(say_color)} {(warn)} 
                      {(DQ ('# still have ') ($ VSub_Name '$test_broken') (' known breakage(s)'))}
                    )
                  ]
                  spids: [16777215 4144]
                )
              ]
              spids: [16777215 4158]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {(DQ ($ VSub_Name '$test_broken'))} {(KW_Bang '!') (Lit_Other '=')} 
                          {(0)}
                        )
                        (C {(test)} {(DQ ($ VSub_Name '$test_fixed'))} {(KW_Bang '!') (Lit_Other '=')} 
                          {(0)}
                        )
                      ]
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:test_remaining spids:[4191])
                          op: Equal
                          rhs: 
                            {
                              (word_part.ArithSubPart
                                anode: 
                                  (arith_expr.ArithBinary
                                    op_id: Arith_Minus
                                    left: 
                                      (arith_expr.ArithBinary
                                        op_id: Arith_Minus
                                        left: (arith_expr.ArithWord w:{($ VSub_Name '$test_count')})
                                        right: (arith_expr.ArithWord w:{($ VSub_Name '$test_broken')})
                                      )
                                    right: (arith_expr.ArithWord w:{($ VSub_Name '$test_fixed')})
                                  )
                                spids: [4192 4205]
                              )
                            }
                          spids: [4191]
                        )
                      ]
                      spids: [4191]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:msg spids:[4208])
                          op: Equal
                          rhs: {(DQ ('remaining ') ($ VSub_Name '$test_remaining') (' test(s)'))}
                          spids: [4208]
                        )
                      ]
                      spids: [4208]
                    )
                  ]
                  spids: [16777215 4188]
                )
              ]
              else_action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:test_remaining spids:[4219])
                      op: Equal
                      rhs: {($ VSub_Name '$test_count')}
                      spids: [4219]
                    )
                  ]
                  spids: [4219]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:msg spids:[4223])
                      op: Equal
                      rhs: {(DQ ($ VSub_Name '$test_count') (' test(s)'))}
                      spids: [4223]
                    )
                  ]
                  spids: [4223]
                )
              ]
              spids: [4216 4230]
            )
            (command.Case
              to_match: {(DQ ($ VSub_Name '$test_failure'))}
              arms: [
                (case_arm
                  pat_list: [{(0)}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$skip_all'))})
                                (C {(test)} {($ VSub_Name '$test_count')} {(-gt)} {(0)})
                              ]
                            )
                          ]
                          action: [(C {(error)} {(DQ ("Can't use skip_all after running some tests"))})]
                          spids: [16777215 4271]
                        )
                      ]
                      spids: [16777215 4281]
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name '$skip_all'))})
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:skip_all spids:[4294])
                              op: Equal
                              rhs: {(DQ (' # SKIP ') ($ VSub_Name '$skip_all'))}
                              spids: [4294]
                            )
                          ]
                          spids: [4294]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {($ VSub_Name '$test_external_has_tap')} {(-eq)} {(0)})]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [(C {(test)} {($ VSub_Name '$test_remaining')} {(-gt)} {(0)})]
                                  action: [
                                    (C {(say_color)} {(pass)} 
                                      {(DQ ('# passed all ') ($ VSub_Name '$msg'))}
                                    )
                                  ]
                                  spids: [16777215 4327]
                                )
                              ]
                              spids: [16777215 4340]
                            )
                            (C {(say)} 
                              {(DQ (1..) ($ VSub_Name '$test_count') ($ VSub_Name '$skip_all'))}
                            )
                          ]
                          spids: [16777215 4313]
                        )
                      ]
                      spids: [16777215 4352]
                    )
                    (command.AndOr
                      ops: [Op_DAmp Op_DAmp]
                      children: [
                        (C {(test)} {(-d)} {(DQ ($ VSub_Name '$remove_trash'))})
                        (C {(cd)} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(dirname)} {(DQ ($ VSub_Name '$remove_trash'))})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [4370 4376]
                              )
                            )
                          }
                        )
                        (C {(rm)} {(-rf)} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(basename)} {(DQ ($ VSub_Name '$remove_trash'))})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [4387 4393]
                              )
                            )
                          }
                        )
                      ]
                    )
                    (C {(test_at_end_hook_)})
                    (command.ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {(0)}
                    )
                  ]
                  spids: [4242 4243 4406 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {($ VSub_Name '$test_external_has_tap')} {(-eq)} {(0)})]
                          action: [
                            (C {(say_color)} {(error)} 
                              {
                                (DQ ('# failed ') ($ VSub_Name '$test_failure') (' among ') 
                                  ($ VSub_Name '$msg')
                                )
                              }
                            )
                            (C {(say)} {(DQ (1..) ($ VSub_Name '$test_count'))})
                          ]
                          spids: [16777215 4425]
                        )
                      ]
                      spids: [16777215 4448]
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {(1)}
                    )
                  ]
                  spids: [4410 4411 4456 16777215]
                )
              ]
              spids: [4233 4239 4460]
            )
          ]
          spids: [4005]
        )
      spids: [4000 4004]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$valgrind'))})]
          action: [
            (command.FuncDef
              name: make_symlink
              body: 
                (command.BraceGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DAmp Op_DPipe]
                      children: [
                        (C {(test)} {(-h)} {(DQ ($ VSub_Number '$2'))})
                        (C {(test)} {(DQ ($ VSub_Number '$1'))} {(Lit_Other '=')} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(readlink)} {(DQ ($ VSub_Number '$2'))})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [4506 4512]
                              )
                            )
                          }
                        )
                        (command.BraceGroup
                          children: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [(C {(mkdir)} {(DQ ($ VSub_Number '$2')) (.lock)})]
                                  action: [
                                    (command.AndOr
                                      ops: [Op_DAmp Op_DAmp]
                                      children: [
                                        (C {(rm)} {(-f)} {(DQ ($ VSub_Number '$2'))})
                                        (C {(ln)} {(-s)} {(DQ ($ VSub_Number '$1'))} 
                                          {(DQ ($ VSub_Number '$2'))}
                                        )
                                        (C {(rm)} {(-r)} {(DQ ($ VSub_Number '$2')) (.lock)})
                                      ]
                                    )
                                  ]
                                  spids: [16777215 4534]
                                )
                              ]
                              else_action: [
                                (command.WhileUntil
                                  keyword: <KW_While while>
                                  cond: [(C {(test)} {(-d)} {(DQ ($ VSub_Number '$2')) (.lock)})]
                                  body: 
                                    (command.DoGroup
                                      children: [
                                        (C {(say)} 
                                          {(DQ ('Waiting for lock on ') ($ VSub_Number '$2') (.))}
                                        )
                                        (C {(sleep)} {(1)})
                                      ]
                                      spids: [4588 4605]
                                    )
                                )
                              ]
                              spids: [4573 4608]
                            )
                          ]
                          spids: [4517]
                        )
                      ]
                    )
                  ]
                  spids: [4483]
                )
              spids: [4478 4482]
            )
            (command.FuncDef
              name: make_valgrind_symlink
              body: 
                (command.BraceGroup
                  children: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DPipe Op_DPipe]
                          children: [
                            (C {(test)} {(-x)} {(DQ ($ VSub_Number '$1'))})
                            (C {(test)} {(DQ ('# '))} {(Lit_Other '=')} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (command.SimpleCommand
                                            words: [{(head)} {(-c)} {(2)}]
                                            redirects: [
                                              (redir.Redir
                                                op: <Redir_Less '<'>
                                                fd: 16777215
                                                arg_word: {(DQ ($ VSub_Number '$1'))}
                                              )
                                            ]
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [4654 4665]
                                  )
                                )
                              }
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Return return>
                            )
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:base spids:[4676])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(basename)} {(DQ ($ VSub_Number '$1'))})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [4677 4683]
                              )
                            }
                          spids: [4676]
                        )
                      ]
                      spids: [4676]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:symlink_target spids:[4686])
                          op: Equal
                          rhs: {($ VSub_Name '$GIT_BUILD_DIR') (/) ($ VSub_Name '$base')}
                          spids: [4686]
                        )
                      ]
                      spids: [4686]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.AndOr
                              ops: [Op_DAmp Op_DAmp]
                              children: [
                                (C {(test)} {(-x)} {(DQ ($ VSub_Name '$symlink_target'))})
                                (C {(test)} {(KW_Bang '!')} {(-d)} {(DQ ($ VSub_Name '$symlink_target'))})
                                (C {(test)} {(DQ ('#!'))} {(KW_Bang '!') (Lit_Other '=')} 
                                  {
                                    (DQ 
                                      (word_part.CommandSubPart
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (command.SimpleCommand
                                                words: [{(head)} {(-c)} {(2)}]
                                                redirects: [
                                                  (redir.Redir
                                                    op: <Redir_Less '<'>
                                                    fd: 16777215
                                                    arg_word: {(DQ ($ VSub_Name '$symlink_target'))}
                                                  )
                                                ]
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [4732 4744]
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:symlink_target spids:[4751])
                                  op: Equal
                                  rhs: {(../valgrind.sh)}
                                  spids: [4751]
                                )
                              ]
                              spids: [4751]
                            )
                          ]
                          spids: [16777215 4748]
                        )
                      ]
                      spids: [16777215 4755]
                    )
                    (command.Case
                      to_match: {(DQ ($ VSub_Name '$base'))}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Other '*') (.sh)} {(Lit_Other '*') (.perl)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:symlink_target spids:[4775])
                                  op: Equal
                                  rhs: {(../unprocessed-script)}
                                  spids: [4775]
                                )
                              ]
                              spids: [4775]
                            )
                          ]
                          spids: [4767 4772 16777215 4779]
                        )
                      ]
                      spids: [4758 4764 4779]
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(make_symlink)} {(DQ ($ VSub_Name '$symlink_target'))} 
                          {(DQ ($ VSub_Name '$GIT_VALGRIND') (/bin/) ($ VSub_Name '$base'))}
                        )
                        (command.ControlFlow token:<ControlFlow_Exit exit>)
                      ]
                    )
                  ]
                  spids: [4623]
                )
              spids: [4618 4622]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:GIT_VALGRIND spids:[4811])
                  op: Equal
                  rhs: {($ VSub_Name '$TEST_DIRECTORY') (/valgrind)}
                  spids: [4811]
                )
              ]
              spids: [4811]
            )
            (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name '$GIT_VALGRIND')) (/bin)})
            (command.ForEach
              iter_name: file
              iter_words: [
                {($ VSub_Name '$GIT_BUILD_DIR') (/git) (Lit_Other '*')}
                {($ VSub_Name '$GIT_BUILD_DIR') (/t/helper/test-) (Lit_Other '*')}
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [(C {(make_valgrind_symlink)} {($ VSub_Name '$file')})]
                  spids: [4841 4849]
                )
              spids: [4831 16777215]
            )
            (C {(make_symlink)} {(DQ ($ VSub_Name '$GIT_BUILD_DIR')) (/mergetools)} 
              {(DQ ($ VSub_Name '$GIT_VALGRIND') (/bin/mergetools))}
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:OLDIFS spids:[4869])
                  op: Equal
                  rhs: {($ VSub_Name '$IFS')}
                  spids: [4869]
                )
              ]
              spids: [4869]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:IFS spids:[4873])
                  op: Equal
                  rhs: {(Lit_Other ':')}
                  spids: [4873]
                )
              ]
              spids: [4873]
            )
            (command.ForEach
              iter_name: path
              iter_words: [{($ VSub_Name '$PATH')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Pipeline
                      children: [
                        (command.SimpleCommand
                          words: [{(ls)} {(DQ ($ VSub_Name '$path')) (/git-) (Lit_Other '*')}]
                          redirects: [(redir.Redir op:<Redir_Great '2>'> fd:2 arg_word:{(/dev/null)})]
                        )
                        (command.WhileUntil
                          keyword: <KW_While while>
                          cond: [(C {(read)} {(file)})]
                          body: 
                            (command.DoGroup
                              children: [(C {(make_valgrind_symlink)} {(DQ ($ VSub_Name '$file'))})]
                              spids: [4911 4921]
                            )
                        )
                      ]
                      negated: F
                    )
                  ]
                  spids: [4886 4924]
                )
              spids: [4882 16777215]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:IFS spids:[4927])
                  op: Equal
                  rhs: {($ VSub_Name '$OLDIFS')}
                  spids: [4927]
                )
              ]
              spids: [4927]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:PATH spids:[4931])
                  op: Equal
                  rhs: {($ VSub_Name '$GIT_VALGRIND') (/bin) (Lit_Other ':') ($ VSub_Name '$PATH')}
                  spids: [4931]
                )
              ]
              spids: [4931]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:GIT_EXEC_PATH spids:[4938])
                  op: Equal
                  rhs: {($ VSub_Name '$GIT_VALGRIND') (/bin)}
                  spids: [4938]
                )
              ]
              spids: [4938]
            )
            (C {(export)} {(GIT_VALGRIND)})
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:GIT_VALGRIND_MODE spids:[4948])
                  op: Equal
                  rhs: {(DQ ($ VSub_Name '$valgrind'))}
                  spids: [4948]
                )
              ]
              spids: [4948]
            )
            (C {(export)} {(GIT_VALGRIND_MODE)})
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:GIT_VALGRIND_ENABLED spids:[4959])
                  op: Equal
                  rhs: {(t)}
                  spids: [4959]
                )
              ]
              spids: [4959]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$valgrind_only'))})
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:GIT_VALGRIND_ENABLED spids:[4973])
                      op: Equal
                      rhs: (word.EmptyWord)
                      spids: [4973]
                    )
                  ]
                  spids: [4973]
                )
              ]
            )
            (C {(export)} {(GIT_VALGRIND_ENABLED)})
          ]
          spids: [16777215 4475]
        )
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$GIT_TEST_INSTALLED'))})]
          action: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:GIT_EXEC_PATH spids:[4993])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {($ VSub_Name '$GIT_TEST_INSTALLED') (/git)} {(--exec-path)})
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [4994 4999]
                          )
                        }
                      spids: [4993]
                    )
                  ]
                  spids: [4993]
                )
                (C {(error)} {(DQ ('Cannot run git from ') ($ VSub_Name '$GIT_TEST_INSTALLED') (.))})
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:PATH spids:[5013])
                  op: Equal
                  rhs: 
                    {($ VSub_Name '$GIT_TEST_INSTALLED') (Lit_Other ':') 
                      ($ VSub_Name '$GIT_BUILD_DIR') (Lit_Other ':') ($ VSub_Name '$PATH')
                    }
                  spids: [5013]
                )
              ]
              spids: [5013]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:GIT_EXEC_PATH spids:[5021])
                  op: Equal
                  rhs: 
                    {
                      (word_part.BracedVarSub
                        token: <VSub_Name GIT_TEST_EXEC_PATH>
                        suffix_op: 
                          (suffix_op.StringUnary
                            op_id: VTest_ColonHyphen
                            arg_word: {($ VSub_Name '$GIT_EXEC_PATH')}
                          )
                        spids: [5022 5026]
                      )
                    }
                  spids: [5021]
                )
              ]
              spids: [5021]
            )
          ]
          spids: [4980 4990]
        )
      ]
      else_action: [
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:git_bin_dir spids:[5034])
              op: Equal
              rhs: {(DQ ($ VSub_Name '$GIT_BUILD_DIR') (/bin-wrappers))}
              spids: [5034]
            )
          ]
          spids: [5034]
        )
        (command.If
          arms: [
            (if_arm
              cond: [
                (command.Pipeline
                  children: [(C {(test)} {(-x)} {(DQ ($ VSub_Name '$git_bin_dir') (/git))})]
                  negated: T
                )
              ]
              action: [
                (command.If
                  arms: [
                    (if_arm
                      cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$with_dashes'))})]
                      action: [
                        (C {(say)} 
                          {
                            (DQ ($ VSub_Name '$git_bin_dir') 
                              ('/git is not executable; using GIT_EXEC_PATH')
                            )
                          }
                        )
                      ]
                      spids: [16777215 5069]
                    )
                  ]
                  spids: [16777215 5080]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:with_dashes spids:[5083])
                      op: Equal
                      rhs: {(t)}
                      spids: [5083]
                    )
                  ]
                  spids: [5083]
                )
              ]
              spids: [16777215 5055]
            )
          ]
          spids: [16777215 5087]
        )
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:PATH spids:[5090])
              op: Equal
              rhs: {(DQ ($ VSub_Name '$git_bin_dir') (':') ($ VSub_Name '$PATH'))}
              spids: [5090]
            )
          ]
          spids: [5090]
        )
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:GIT_EXEC_PATH spids:[5098])
              op: Equal
              rhs: {($ VSub_Name '$GIT_BUILD_DIR')}
              spids: [5098]
            )
          ]
          spids: [5098]
        )
        (command.If
          arms: [
            (if_arm
              cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$with_dashes'))})]
              action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:PATH spids:[5116])
                      op: Equal
                      rhs: {(DQ ($ VSub_Name '$GIT_BUILD_DIR') (':') ($ VSub_Name '$PATH'))}
                      spids: [5116]
                    )
                  ]
                  spids: [5116]
                )
              ]
              spids: [16777215 5113]
            )
          ]
          spids: [16777215 5124]
        )
      ]
      spids: [5028 5126]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:GIT_TEMPLATE_DIR spids:[5128])
          op: Equal
          rhs: {(DQ ($ VSub_Name '$GIT_BUILD_DIR')) (/templates/blt)}
          spids: [5128]
        )
      ]
      spids: [5128]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:GIT_CONFIG_NOSYSTEM spids:[5134])
          op: Equal
          rhs: {(1)}
          spids: [5134]
        )
      ]
      spids: [5134]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:GIT_ATTR_NOSYSTEM spids:[5137])
          op: Equal
          rhs: {(1)}
          spids: [5137]
        )
      ]
      spids: [5137]
    )
    (C {(export)} {(PATH)} {(GIT_EXEC_PATH)} {(GIT_TEMPLATE_DIR)} {(GIT_CONFIG_NOSYSTEM)} 
      {(GIT_ATTR_NOSYSTEM)}
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$GIT_TEST_CMP'))})]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$GIT_TEST_CMP_USE_COPIED_CONTEXT'))})]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:GIT_TEST_CMP spids:[5180])
                          op: Equal
                          rhs: {(DQ ($ VSub_Name '$DIFF') (' -c'))}
                          spids: [5180]
                        )
                      ]
                      spids: [5180]
                    )
                  ]
                  spids: [16777215 5177]
                )
              ]
              else_action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:GIT_TEST_CMP spids:[5190])
                      op: Equal
                      rhs: {(DQ ($ VSub_Name '$DIFF') (' -u'))}
                      spids: [5190]
                    )
                  ]
                  spids: [5190]
                )
              ]
              spids: [5187 5197]
            )
          ]
          spids: [16777215 5163]
        )
      ]
      spids: [16777215 5199]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:GITPERLLIB spids:[5202])
          op: Equal
          rhs: 
            {(DQ ($ VSub_Name '$GIT_BUILD_DIR')) (/perl/blib/lib) (Lit_Other ':') 
              (DQ ($ VSub_Name '$GIT_BUILD_DIR')) (/perl/blib/arch/auto/Git)
            }
          spids: [5202]
        )
      ]
      spids: [5202]
    )
    (C {(export)} {(GITPERLLIB)})
    (command.AndOr
      ops: [Op_DPipe]
      children: [
        (C {(test)} {(-d)} {(DQ ($ VSub_Name '$GIT_BUILD_DIR')) (/templates/blt)})
        (command.BraceGroup
          children: [(C {(error)} {(DQ ("You haven't built things yet, have you?"))})]
          spids: [5228]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Pipeline
              children: [
                (C {(test)} {(-x)} {(DQ ($ VSub_Name '$GIT_BUILD_DIR')) (/t/helper/test-chmtime)})
              ]
              negated: T
            )
          ]
          action: [
            (command.SimpleCommand
              words: [{(echo)} {(SQ <'You need to build test-chmtime:'>)}]
              redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
            )
            (command.SimpleCommand
              words: [
                {(echo)}
                {(SQ <'Run "make t/helper/test-chmtime" in the source (toplevel) directory'>)}
              ]
              redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
            )
            (command.ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
          ]
          spids: [16777215 5253]
        )
      ]
      spids: [16777215 5280]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:TRASH_DIRECTORY spids:[5286])
          op: Equal
          rhs: 
            {
              (DQ ('trash directory.') 
                (word_part.CommandSubPart
                  command_list: 
                    (command.CommandList
                      children: [(C {(basename)} {(DQ ($ VSub_Number '$0'))} {(.sh)})]
                    )
                  left_token: <Left_CommandSub '$('>
                  spids: [5289 5297]
                )
              )
            }
          spids: [5286]
        )
      ]
      spids: [5286]
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [
        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$root'))})
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:TRASH_DIRECTORY spids:[5310])
              op: Equal
              rhs: {(DQ ($ VSub_Name '$root') (/) ($ VSub_Name '$TRASH_DIRECTORY'))}
              spids: [5310]
            )
          ]
          spids: [5310]
        )
      ]
    )
    (command.Case
      to_match: {(DQ ($ VSub_Name '$TRASH_DIRECTORY'))}
      arms: [
        (case_arm pat_list:[{(/) (Lit_Other '*')}] spids:[5325 5327 5329 16777215])
        (case_arm
          pat_list: [{(Lit_Other '*')}]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:TRASH_DIRECTORY spids:[5338])
                  op: Equal
                  rhs: 
                    {
                      (DQ ($ VSub_Name '$TEST_OUTPUT_DIRECTORY') (/) ($ VSub_Name '$TRASH_DIRECTORY'))
                    }
                  spids: [5338]
                )
              ]
              spids: [5338]
            )
          ]
          spids: [5335 5336 5345 16777215]
        )
      ]
      spids: [5317 5323 5347]
    )
    (command.AndOr
      ops: [Op_DPipe]
      children: [
        (C {(test)} {(KW_Bang '!')} {(-z)} {(DQ ($ VSub_Name '$debug'))})
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:remove_trash spids:[5361])
              op: Equal
              rhs: {($ VSub_Name '$TRASH_DIRECTORY')}
              spids: [5361]
            )
          ]
          spids: [5361]
        )
      ]
    )
    (command.AndOr
      ops: [Op_DPipe]
      children: [
        (C {(rm)} {(-fr)} {(DQ ($ VSub_Name '$TRASH_DIRECTORY'))})
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:GIT_EXIT_OK spids:[5377])
                  op: Equal
                  rhs: {(t)}
                  spids: [5377]
                )
              ]
              spids: [5377]
            )
            (command.SimpleCommand
              words: [{(echo)} {(DQ ('FATAL: Cannot prepare test area'))}]
              redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(5)})]
            )
            (command.ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
          ]
          spids: [5374]
        )
      ]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:HOME spids:[5398])
          op: Equal
          rhs: {(DQ ($ VSub_Name '$TRASH_DIRECTORY'))}
          spids: [5398]
        )
      ]
      spids: [5398]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:GNUPGHOME spids:[5403])
          op: Equal
          rhs: {(DQ ($ VSub_Name '$HOME') (/gnupg-home-not-used))}
          spids: [5403]
        )
      ]
      spids: [5403]
    )
    (C {(export)} {(HOME)} {(GNUPGHOME)})
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$TEST_NO_CREATE_REPO'))})]
          action: [(C {(test_create_repo)} {(DQ ($ VSub_Name '$TRASH_DIRECTORY'))})]
          spids: [16777215 5426]
        )
      ]
      else_action: [(C {(mkdir)} {(-p)} {(DQ ($ VSub_Name '$TRASH_DIRECTORY'))})]
      spids: [5435 5446]
    )
    (command.AndOr
      ops: [Op_DPipe]
      children: [
        (C {(cd)} {(-P)} {(DQ ($ VSub_Name '$TRASH_DIRECTORY'))})
        (command.ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
      ]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:this_test spids:[5469])
          op: Equal
          rhs: 
            {
              (word_part.BracedVarSub
                token: <VSub_Number 0>
                suffix_op: (suffix_op.StringUnary op_id:VOp1_DPound arg_word:{('*') (Lit_Slash /)})
                spids: [5470 5475]
              )
            }
          spids: [5469]
        )
      ]
      spids: [5469]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:this_test spids:[5477])
          op: Equal
          rhs: 
            {
              (word_part.BracedVarSub
                token: <VSub_Name this_test>
                suffix_op: (suffix_op.StringUnary op_id:VOp1_DPercent arg_word:{('-*')})
                spids: [5478 5482]
              )
            }
          spids: [5477]
        )
      ]
      spids: [5477]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (C {(match_pattern_list)} {(DQ ($ VSub_Name '$this_test'))} 
              {($ VSub_Name '$GIT_SKIP_TESTS')}
            )
          ]
          action: [
            (command.SimpleCommand
              words: [
                {(say_color)}
                {(info)}
                {(DQ ('skipping test ') ($ VSub_Name '$this_test') (' altogether'))}
              ]
              redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(3)})]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:skip_all spids:[5511])
                  op: Equal
                  rhs: {(DQ ('skip all tests in ') ($ VSub_Name '$this_test'))}
                  spids: [5511]
                )
              ]
              spids: [5511]
            )
            (C {(test_done)})
          ]
          spids: [16777215 5494]
        )
      ]
      spids: [16777215 5520]
    )
    (command.FuncDef
      name: yes
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {($ VSub_Pound '$#')} {(Lit_Other '=')} {(0)})]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:y spids:[5548])
                          op: Equal
                          rhs: {(y)}
                          spids: [5548]
                        )
                      ]
                      spids: [5548]
                    )
                  ]
                  spids: [16777215 5545]
                )
              ]
              else_action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:y spids:[5555])
                      op: Equal
                      rhs: {(DQ ($ VSub_Star '$*'))}
                      spids: [5555]
                    )
                  ]
                  spids: [5555]
                )
              ]
              spids: [5552 5561]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:i spids:[5565])
                  op: Equal
                  rhs: {(0)}
                  spids: [5565]
                )
              ]
              spids: [5565]
            )
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(C {(test)} {($ VSub_Name '$i')} {(-lt)} {(99)})]
              body: 
                (command.DoGroup
                  children: [
                    (C {(echo)} {(DQ ($ VSub_Name '$y'))})
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:i spids:[5590])
                          op: Equal
                          rhs: 
                            {
                              (word_part.ArithSubPart
                                anode: 
                                  (arith_expr.ArithBinary
                                    op_id: Arith_Plus
                                    left: (arith_expr.ArithWord w:{($ VSub_Name '$i')})
                                    right: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                  )
                                spids: [5591 5596]
                              )
                            }
                          spids: [5590]
                        )
                      ]
                      spids: [5590]
                    )
                  ]
                  spids: [5580 5599]
                )
            )
          ]
          spids: [5531]
        )
      spids: [5526 5530]
    )
    (command.Case
      to_match: 
        {
          (word_part.CommandSubPart
            command_list: (command.CommandList children:[(C {(uname)} {(-s)})])
            left_token: <Left_CommandSub '$('>
            spids: [5609 5613]
          )
        }
      arms: [
        (case_arm
          pat_list: [{(Lit_Other '*') (MINGW) (Lit_Other '*')}]
          action: [
            (command.FuncDef
              name: sort
              body: 
                (command.BraceGroup
                  children: [(C {(/usr/bin/sort)} {(DQ ($ VSub_At '$@'))})]
                  spids: [5632]
                )
              spids: [5627 5631]
            )
            (command.FuncDef
              name: find
              body: 
                (command.BraceGroup
                  children: [(C {(/usr/bin/find)} {(DQ ($ VSub_At '$@'))})]
                  spids: [5650]
                )
              spids: [5645 5649]
            )
            (command.FuncDef
              name: sum
              body: 
                (command.BraceGroup
                  children: [(C {(md5sum)} {(DQ ($ VSub_At '$@'))})]
                  spids: [5668]
                )
              spids: [5663 5667]
            )
            (command.FuncDef
              name: pwd
              body: (command.BraceGroup children:[(C {(builtin)} {(pwd)} {(-W)})] spids:[5690])
              spids: [5685 5689]
            )
            (C {(test_set_prereq)} {(MINGW)})
            (C {(test_set_prereq)} {(NATIVE_CRLF)})
            (C {(test_set_prereq)} {(SED_STRIPS_CR)})
            (C {(test_set_prereq)} {(GREP_STRIPS_CR)})
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:GIT_TEST_CMP spids:[5735])
                  op: Equal
                  rhs: {(mingw_test_cmp)}
                  spids: [5735]
                )
              ]
              spids: [5735]
            )
          ]
          spids: [5617 5620 5739 16777215]
        )
        (case_arm
          pat_list: [{(Lit_Other '*') (CYGWIN) (Lit_Other '*')}]
          action: [
            (C {(test_set_prereq)} {(POSIXPERM)})
            (C {(test_set_prereq)} {(EXECKEEPSPID)})
            (C {(test_set_prereq)} {(CYGWIN)})
            (C {(test_set_prereq)} {(SED_STRIPS_CR)})
            (C {(test_set_prereq)} {(GREP_STRIPS_CR)})
          ]
          spids: [5741 5744 5772 16777215]
        )
        (case_arm
          pat_list: [{(Lit_Other '*')}]
          action: [
            (C {(test_set_prereq)} {(POSIXPERM)})
            (C {(test_set_prereq)} {(BSLASHPSPEC)})
            (C {(test_set_prereq)} {(EXECKEEPSPID)})
          ]
          spids: [5774 5775 5793 16777215]
        )
      ]
      spids: [5607 5615 5795]
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [
        (command.Subshell
          child: 
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:COLUMNS spids:[5800])
                      op: Equal
                      rhs: {(1)}
                      spids: [5800]
                    )
                  ]
                  spids: [5800]
                )
                (C {(test)} {($ VSub_Name '$COLUMNS')} {(Lit_Other '=')} {(1)})
              ]
            )
          spids: [5798 5813]
        )
        (C {(test_set_prereq)} {(COLUMNS_CAN_BE_1)})
      ]
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$NO_PERL'))}) (C {(test_set_prereq)} {(PERL)})]
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [
        (C {(test)} {(-z)} {(DQ ($ VSub_Name '$NO_PYTHON'))})
        (C {(test_set_prereq)} {(PYTHON)})
      ]
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [
        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$USE_LIBPCRE'))})
        (C {(test_set_prereq)} {(LIBPCRE)})
      ]
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [
        (C {(test)} {(-z)} {(DQ ($ VSub_Name '$NO_GETTEXT'))})
        (C {(test_set_prereq)} {(GETTEXT)})
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$GETTEXT_POISON'))})]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:GIT_GETTEXT_POISON spids:[5894])
                  op: Equal
                  rhs: {(YesPlease)}
                  spids: [5894]
                )
              ]
              spids: [5894]
            )
            (C {(export)} {(GIT_GETTEXT_POISON)})
            (C {(test_set_prereq)} {(GETTEXT_POISON)})
          ]
          spids: [16777215 5891]
        )
      ]
      else_action: [(C {(test_set_prereq)} {(C_LOCALE_OUTPUT)})]
      spids: [5907 5914]
    )
    (command.FuncDef
      name: test_i18ncmp
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$GETTEXT_POISON'))})
                (C {(test_cmp)} {(DQ ($ VSub_At '$@'))})
              ]
            )
          ]
          spids: [5934]
        )
      spids: [5929 5933]
    )
    (command.FuncDef
      name: test_i18ngrep
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$GETTEXT_POISON'))})]
                  action: [(C {(Lit_Other ':')})]
                  spids: [16777215 5990]
                )
                (if_arm
                  cond: [(C {(test)} {(DQ ('x!'))} {(Lit_Other '=')} {(DQ (x) ($ VSub_Number '$1'))})]
                  action: [
                    (C {(shift)})
                    (command.Pipeline
                      children: [(C {(grep)} {(DQ ($ VSub_At '$@'))})]
                      negated: T
                    )
                  ]
                  spids: [5999 6015]
                )
              ]
              else_action: [(C {(grep)} {(DQ ($ VSub_At '$@'))})]
              spids: [6030 6040]
            )
          ]
          spids: [5976]
        )
      spids: [5971 5975]
    )
    (C {(test_lazy_prereq)} {(PIPE)} 
      {
        (SQ <'\n'> <'\t# test whether the filesystem supports FIFOs\n'> <'\tcase $(uname -s) in\n'> 
          <'\tCYGWIN*|MINGW*)\n'> <'\t\tfalse\n'> <'\t\t;;\n'> <'\t*)\n'> <'\t\trm -f testfifo && mkfifo testfifo\n'> <'\t\t;;\n'> 
          <'\tesac\n'>
        )
      }
    )
    (C {(test_lazy_prereq)} {(SYMLINKS)} 
      {
        (SQ <'\n'> <'\t# test whether the filesystem supports symbolic links\n'> 
          <'\tln -s x y && test -h y\n'>
        )
      }
    )
    (C {(test_lazy_prereq)} {(FILEMODE)} 
      {(SQ <'\n'> <'\ttest "$(git config --bool core.filemode)" = true\n'>)}
    )
    (C {(test_lazy_prereq)} {(CASE_INSENSITIVE_FS)} 
      {
        (SQ <'\n'> <'\techo good >CamelCase &&\n'> <'\techo bad >camelcase &&\n'> 
          <'\ttest "$(cat CamelCase)" != good\n'>
        )
      }
    )
    (C {(test_lazy_prereq)} {(UTF8_NFD_TO_NFC)} 
      {
        (SQ <'\n'> <'\t# check whether FS converts nfd unicode to nfc\n'> 
          <'\tauml=$(printf "\\303\\244")\n'> <'\taumlcdiar=$(printf "\\141\\314\\210")\n'> <'\t>"$auml" &&\n'> <'\tcase "$(echo *)" in\n'> 
          <'\t"$aumlcdiar")\n'> <'\t\ttrue ;;\n'> <'\t*)\n'> <'\t\tfalse ;;\n'> <'\tesac\n'>
        )
      }
    )
    (C {(test_lazy_prereq)} {(AUTOIDENT)} 
      {
        (SQ <'\n'> <'\tsane_unset GIT_AUTHOR_NAME &&\n'> <'\tsane_unset GIT_AUTHOR_EMAIL &&\n'> 
          <'\tgit var GIT_AUTHOR_IDENT\n'>
        )
      }
    )
    (C {(test_lazy_prereq)} {(EXPENSIVE)} {(SQ <'\n'> <'\ttest -n "$GIT_TEST_LONG"\n'>)})
    (C {(test_lazy_prereq)} {(USR_BIN_TIME)} {(SQ <'\n'> <'\ttest -x /usr/bin/time\n'>)})
    (C {(test_lazy_prereq)} {(NOT_ROOT)} {(SQ <'\n'> <'\tuid=$(id -u) &&\n'> <'\ttest "$uid" != 0\n'>)})
    (C {(test_lazy_prereq)} {(JGIT)} {(SQ <'\n'> <'\ttype jgit\n'>)})
    (C {(test_lazy_prereq)} {(SANITY)} 
      {
        (SQ <'\n'> <'\tmkdir SANETESTD.1 SANETESTD.2 &&\n'> <'\n'> 
          <'\tchmod +w SANETESTD.1 SANETESTD.2 &&\n'> <'\t>SANETESTD.1/x 2>SANETESTD.2/x &&\n'> <'\tchmod -w SANETESTD.1 &&\n'> 
          <'\tchmod -r SANETESTD.1/x &&\n'> <'\tchmod -rx SANETESTD.2 ||\n'> <'\terror "bug in test sript: cannot prepare SANETESTD"\n'> <'\n'> 
          <'\t! test -r SANETESTD.1/x &&\n'> <'\t! rm SANETESTD.1/x && ! test -f SANETESTD.2/x\n'> <'\tstatus=$?\n'> <'\n'> 
          <'\tchmod +rwx SANETESTD.1 SANETESTD.2 &&\n'> <'\trm -rf SANETESTD.1 SANETESTD.2 ||\n'> <'\terror "bug in test sript: cannot clean SANETESTD"\n'> 
          <'\treturn $status\n'>
        )
      }
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:GIT_UNZIP spids:[6225])
          op: Equal
          rhs: 
            {
              (word_part.BracedVarSub
                token: <VSub_Name GIT_UNZIP>
                suffix_op: (suffix_op.StringUnary op_id:VTest_ColonHyphen arg_word:{(unzip)})
                spids: [6226 6230]
              )
            }
          spids: [6225]
        )
      ]
      spids: [6225]
    )
    (C {(test_lazy_prereq)} {(UNZIP)} {(SQ <'\n'> <'\t"$GIT_UNZIP" -v\n'> <'\ttest $? -ne 127\n'>)})
    (command.FuncDef
      name: run_with_limited_cmdline
      body: 
        (command.BraceGroup
          children: [
            (command.Subshell
              child: 
                (command.AndOr
                  ops: [Op_DAmp]
                  children: [(C {(ulimit)} {(-s)} {(128)}) (C {(DQ ($ VSub_At '$@'))})]
                )
              spids: [6251 6263]
            )
          ]
          spids: [6248]
        )
      spids: [6243 6247]
    )
    (C {(test_lazy_prereq)} {(CMDLINE_LIMIT)} {(SQ <'run_with_limited_cmdline true'>)})
    (command.FuncDef
      name: build_option
      body: 
        (command.BraceGroup
          children: [
            (command.Pipeline
              children: [
                (C {(git)} {(version)} {(--build-options)})
                (C {(sed)} {(-ne)} {(DQ ('s/^') ($ VSub_Number '$1') (': //p'))})
              ]
              negated: F
            )
          ]
          spids: [6282]
        )
      spids: [6277 6281]
    )
    (C {(test_lazy_prereq)} {(LONG_IS_64BIT)} 
      {(SQ <'\n'> <'\ttest 8 -le "$(build_option sizeof-long)"\n'>)}
    )
  ]
)