(command.CommandList
  children: [
    (command.If
      arms: [
        (if_arm
          cond: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$TEST_DIRECTORY'))})]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:TEST_DIRECTORY)
                  op: assign_op.Equal
                  rhs: {(command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<pwd>}))}
                  spids: [80]
                )
              ]
            )
          ]
          spids: [55 65]
        )
      ]
      else_action: [
        (command.AndOr
          ops: [Id.Op_DPipe]
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:TEST_DIRECTORY)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.AndOr
                            ops: [Id.Op_DAmp]
                            children: [
                              (C {<cd>} {(DQ ($ Id.VSub_DollarName '$TEST_DIRECTORY'))})
                              (C {<pwd>})
                            ]
                          )
                      )
                    }
                  spids: [96]
                )
              ]
            )
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$TEST_OUTPUT_DIRECTORY'))})]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:TEST_OUTPUT_DIRECTORY)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$TEST_DIRECTORY')}
                  spids: [138]
                )
              ]
            )
          ]
          spids: [117 127]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:GIT_BUILD_DIR)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$TEST_DIRECTORY')) <'/..'>}
          spids: [143]
        )
      ]
    )
    (command.Simple
      words: [{(DQ ($ Id.VSub_DollarName '$GIT_BUILD_DIR') <'/git'>)}]
      redirects: [(redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<'/dev/null'>})]
      do_fork: T
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {<test>} {($ Id.VSub_QMark '$?')} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<1>})]
          action: [
            (command.Simple
              words: [{<echo>} {(SQ <'error: you do not seem to have built git yet.'>)}]
              redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
              do_fork: T
            )
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
          spids: [164 175]
        )
      ]
    )
    (C {<.>} {(DQ ($ Id.VSub_DollarName '$GIT_BUILD_DIR')) <'/GIT-BUILD-OPTIONS'>})
    (C {<export>} {<PERL_PATH>} {<SHELL_PATH>})
    (command.Case
      to_match: 
        {(DQ ($ Id.VSub_DollarName '$GIT_TEST_TEE_STARTED') <', '> ($ Id.VSub_Star '$*') <' '>)}
      arms: [
        (case_arm
          pat_list: [{<Id.KW_Done done> <Id.Lit_Comma ','> <Id.Lit_Star '*'>}]
          spids: [226 229 236 -1]
        )
        (case_arm
          pat_list: [
            {<Id.Lit_Star '*'> (SQ <' --tee '>) <Id.Lit_Star '*'>}
            {<Id.Lit_Star '*'> (SQ <' --va'>) <Id.Lit_Star '*'>}
            {<Id.Lit_Star '*'> (SQ <' --verbose-log '>) <Id.Lit_Star '*'>}
          ]
          action: [
            (C {<mkdir>} {<-p>} {(DQ ($ Id.VSub_DollarName '$TEST_OUTPUT_DIRECTORY') <'/test-results'>)})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:BASE)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ ($ Id.VSub_DollarName '$TEST_OUTPUT_DIRECTORY') <'/test-results/'> 
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: (C {<basename>} {(DQ ($ Id.VSub_Number '$0'))} {<.sh>})
                        )
                      )
                    }
                  spids: [268]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:GIT_TEST_TEE_OUTPUT_FILE)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$BASE') <.out>}
                  spids: [293]
                )
              ]
            )
            (C {<export>} {<GIT_TEST_TEE_OUTPUT_FILE>})
            (command.Simple
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_DollarName '$GIT_TEST_TEE_OUTPUT_FILE'))}
                )
              ]
              do_fork: F
            )
            (command.Pipeline
              children: [
                (command.Subshell
                  child: 
                    (command.CommandList
                      children: [
                        (command.Sentence
                          child: 
                            (command.Simple
                              words: [
                                {(${ Id.VSub_Name SHELL_PATH)}
                                {(DQ ($ Id.VSub_Number '$0'))}
                                {(DQ ($ Id.VSub_At '$@'))}
                              ]
                              redirects: [
                                (redir
                                  op: <Id.Redir_GreatAnd '2>&'>
                                  loc: (redir_loc.Fd fd:2)
                                  arg: {<1>}
                                )
                              ]
                              more_env: [
                                (env_pair
                                  name: GIT_TEST_TEE_STARTED
                                  val: {<Id.KW_Done done>}
                                  spids: [320]
                                )
                              ]
                              do_fork: T
                            )
                          terminator: <Id.Op_Semi _>
                        )
                        (command.Simple
                          words: [{<echo>} {($ Id.VSub_QMark '$?')}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {(DQ ($ Id.VSub_DollarName '$BASE') <.exit>)}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                    )
                )
                (C {<tee>} {<-a>} {(DQ ($ Id.VSub_DollarName '$GIT_TEST_TEE_OUTPUT_FILE'))})
              ]
              negated: F
            )
            (C {<test>} 
              {
                (DQ 
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: (C {<cat>} {(DQ ($ Id.VSub_DollarName '$BASE') <.exit>)})
                  )
                )
              } {<Id.Lit_Equals '='>} {<0>}
            )
            (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
          ]
          spids: [238 255 383 -1]
        )
      ]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:LANG) op:assign_op.Equal rhs:{<C>} spids:[394])]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:LC_ALL)
          op: assign_op.Equal
          rhs: {<C>}
          spids: [397]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:PAGER)
          op: assign_op.Equal
          rhs: {<cat>}
          spids: [400]
        )
      ]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:TZ) op:assign_op.Equal rhs:{<UTC>} spids:[403])]
    )
    (C {<export>} {<LANG>} {<LC_ALL>} {<PAGER>} {<TZ>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:EDITOR)
          op: assign_op.Equal
          rhs: {<Id.Lit_Colon ':'>}
          spids: [416]
        )
      ]
    )
    (C {<unset>} {<VISUAL>} {<EMAIL>} {<LANGUAGE>} {<COLUMNS>} 
      {
        (command_sub
          left_token: <Id.Left_DollarParen '$('>
          child: 
            (C {(DQ ($ Id.VSub_DollarName '$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'>
                )
              }
            )
        )
      }
    )
    (C {<unset>} {<XDG_CONFIG_HOME>})
    (C {<unset>} {<GITPERLLIB>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:GIT_AUTHOR_EMAIL)
          op: assign_op.Equal
          rhs: {<author> <Id.Lit_Splice '@example'> <.com>}
          spids: [477]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:GIT_AUTHOR_NAME)
          op: assign_op.Equal
          rhs: {(SQ <'A U Thor'>)}
          spids: [482]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:GIT_COMMITTER_EMAIL)
          op: assign_op.Equal
          rhs: {<committer> <Id.Lit_Splice '@example'> <.com>}
          spids: [487]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:GIT_COMMITTER_NAME)
          op: assign_op.Equal
          rhs: {(SQ <'C O Mitter'>)}
          spids: [492]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:GIT_MERGE_VERBOSITY)
          op: assign_op.Equal
          rhs: {<5>}
          spids: [497]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:GIT_MERGE_AUTOEDIT)
          op: assign_op.Equal
          rhs: {<no>}
          spids: [500]
        )
      ]
    )
    (C {<export>} {<GIT_MERGE_VERBOSITY>} {<GIT_MERGE_AUTOEDIT>})
    (C {<export>} {<GIT_AUTHOR_EMAIL>} {<GIT_AUTHOR_NAME>})
    (C {<export>} {<GIT_COMMITTER_EMAIL>} {<GIT_COMMITTER_NAME>})
    (C {<export>} {<EDITOR>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:GIT_TRACE_BARE)
          op: assign_op.Equal
          rhs: {<1>}
          spids: [529]
        )
      ]
    )
    (C {<export>} {<GIT_TRACE_BARE>})
    (command.If
      arms: [
        (if_arm
          cond: [
            (C {<test>} {<-n>} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name TEST_GIT_INDEX_VERSION>
                    suffix_op: (suffix_op.Unary op_id:Id.VTest_ColonPlus arg_word:{<isset>})
                  )
                )
              }
            )
          ]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:GIT_INDEX_VERSION)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$TEST_GIT_INDEX_VERSION'))}
                  spids: [554]
                )
              ]
            )
            (C {<export>} {<GIT_INDEX_VERSION>})
          ]
          spids: [537 551]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.Simple
                  words: [
                    {<expr>}
                    {(DQ <' '> ($ Id.VSub_DollarName '$GIT_TEST_OPTS') <' '>)}
                    {<Id.Lit_Colon ':'>}
                    {(DQ <'.* --valgrind '>)}
                  ]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<'/dev/null'>}
                    )
                  ]
                  do_fork: T
                )
                (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$TEST_NO_MALLOC_CHECK'))})
              ]
            )
          ]
          action: [
            (command.ShFunction
              name: setup_malloc_check
              body: (BraceGroup children:[(C {<Id.Lit_Colon ':'>} {<nothing>})])
            )
            (command.ShFunction
              name: teardown_malloc_check
              body: (BraceGroup children:[(C {<Id.Lit_Colon ':'>} {<nothing>})])
            )
          ]
          spids: [573 603]
        )
      ]
      else_action: [
        (command.ShFunction
          name: setup_malloc_check
          body: 
            (BraceGroup
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:MALLOC_CHECK_)
                      op: assign_op.Equal
                      rhs: {<3>}
                      spids: [648]
                    )
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:MALLOC_PERTURB_)
                      op: assign_op.Equal
                      rhs: {<165>}
                      spids: [651]
                    )
                  ]
                )
                (C {<export>} {<MALLOC_CHECK_>} {<MALLOC_PERTURB_>})
              ]
            )
        )
        (command.ShFunction
          name: teardown_malloc_check
          body: (BraceGroup children:[(C {<unset>} {<MALLOC_CHECK_>} {<MALLOC_PERTURB_>})])
        )
      ]
    )
    (C {<Id.Lit_Colon ':'>} 
      {
        (braced_var_sub
          token: <Id.VSub_Name ASAN_OPTIONS>
          suffix_op: (suffix_op.Unary op_id:Id.VTest_Equals arg_word:{<'detect_leaks=0'>})
        )
      }
    )
    (C {<export>} {<ASAN_OPTIONS>})
    (C {<unset>} {<CDPATH>})
    (C {<unset>} {<GREP_OPTIONS>})
    (C {<unset>} {<UNZIP>})
    (command.Case
      to_match: 
        {
          (command_sub
            left_token: <Id.Left_DollarParen '$('>
            child: 
              (command.Pipeline
                children: [
                  (C {<echo>} {($ Id.VSub_DollarName '$GIT_TRACE')})
                  (C {<tr>} {(DQ <'[A-Z]'>)} {(DQ <'[a-z]'>)})
                ]
                negated: F
              )
          )
        }
      arms: [
        (case_arm
          pat_list: [{<1>} {<2>} {<true>}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:GIT_TRACE)
                  op: assign_op.Equal
                  rhs: {<4>}
                  spids: [747]
                )
              ]
            )
          ]
          spids: [739 744 751 -1]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:_x05)
          op: assign_op.Equal
          rhs: {(SQ <'[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'>)}
          spids: [765]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:_x40)
          op: assign_op.Equal
          rhs: 
            {
              (DQ ($ Id.VSub_DollarName '$_x05') ($ Id.VSub_DollarName '$_x05') 
                ($ Id.VSub_DollarName '$_x05') ($ Id.VSub_DollarName '$_x05') ($ Id.VSub_DollarName '$_x05') ($ Id.VSub_DollarName '$_x05') 
                ($ Id.VSub_DollarName '$_x05') ($ Id.VSub_DollarName '$_x05')
              )
            }
          spids: [770]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:_z40)
          op: assign_op.Equal
          rhs: {<0000000000000000000000000000000000000000>}
          spids: [786]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:EMPTY_TREE)
          op: assign_op.Equal
          rhs: {<4b825dc642cb6eb9a060e54bf8d69288fbee4904>}
          spids: [790]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:EMPTY_BLOB)
          op: assign_op.Equal
          rhs: {<e69de29bb2d1d6434b8b29ae775ad8c2e48c5391>}
          spids: [793]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:LF)
          op: assign_op.Equal
          rhs: {(SQ <'\n'>)}
          spids: [800]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:u200c)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_DollarParen '$('>
                child: (C {<printf>} {(SQ <'\\342\\200\\214'>)})
              )
            }
          spids: [812]
        )
      ]
    )
    (C {<export>} {<_x05>} {<_x40>} {<_z40>} {<LF>} {<u200c>} {<EMPTY_TREE>} {<EMPTY_BLOB>})
    (command.AndOr
      ops: [Id.Op_DAmp Id.Op_DAmp]
      children: [
        (C {<test>} {(DQ <x> ($ Id.VSub_DollarName '$TERM'))} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} 
          {(DQ <xdumb>)}
        )
        (command.Subshell
          child: 
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp]
              children: [
                (C {<test>} {<-t>} {<1>})
                (command.Simple
                  words: [{<tput>} {<bold>}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<'/dev/null'>}
                    )
                    (redir
                      op: <Id.Redir_GreatAnd '2>&'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<1>}
                    )
                  ]
                  do_fork: T
                )
                (command.Simple
                  words: [{<tput>} {<setaf>} {<1>}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<'/dev/null'>}
                    )
                    (redir
                      op: <Id.Redir_GreatAnd '2>&'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<1>}
                    )
                  ]
                  do_fork: T
                )
                (command.Simple
                  words: [{<tput>} {<sgr0>}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<'/dev/null'>}
                    )
                    (redir
                      op: <Id.Redir_GreatAnd '2>&'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<1>}
                    )
                  ]
                  do_fork: T
                )
              ]
            )
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:color)
              op: assign_op.Equal
              rhs: {<t>}
              spids: [929]
            )
          ]
        )
      ]
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: [(C {<test>} {(DQ ($ Id.VSub_Pound '$#'))} {<-ne>} {<0>})]
      body: 
        (command.DoGroup
          children: [
            (command.Case
              to_match: {(DQ ($ Id.VSub_Number '$1'))}
              arms: [
                (case_arm
                  pat_list: [{<-d>} {<--d>} {<--de>} {<--deb>} {<--debu>} {<--debug>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:debug)
                              op: assign_op.Equal
                              rhs: {<t>}
                              spids: [971]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                  ]
                  spids: [957 968 977 -1]
                )
                (case_arm
                  pat_list: [
                    {<-i>}
                    {<--i>}
                    {<--im>}
                    {<--imm>}
                    {<--imme>}
                    {<--immed>}
                    {<--immedi>}
                    {<--immedia>}
                    {<--immediat>}
                    {<--immediate>}
                  ]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:immediate)
                              op: assign_op.Equal
                              rhs: {<t>}
                              spids: [1002]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                  ]
                  spids: [980 999 1008 -1]
                )
                (case_arm
                  pat_list: [
                    {<-l>}
                    {<--l>}
                    {<--lo>}
                    {<--lon>}
                    {<--long>}
                    {<--long->}
                    {<--long-t>}
                    {<--long-te>}
                    {<--long-tes>}
                    {<--long-test>}
                    {<--long-tests>}
                  ]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:GIT_TEST_LONG)
                              op: assign_op.Equal
                              rhs: {<t>}
                              spids: [1035]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (command.Sentence
                      child: (C {<export>} {<GIT_TEST_LONG>})
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                  ]
                  spids: [1011 1032 1046 -1]
                )
                (case_arm
                  pat_list: [{<-r>}]
                  action: [
                    (command.Sentence
                      child: (C {<shift>})
                      terminator: <Id.Op_Semi _>
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<test>} {(DQ ($ Id.VSub_Pound '$#'))} {<-ne>} {<0>})
                        (BraceGroup
                          children: [
                            (command.Sentence
                              child: 
                                (command.Simple
                                  words: [{<echo>} {(SQ <'error: -r requires an argument'>)}]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_GreatAnd '>&'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {<2>}
                                    )
                                  ]
                                  do_fork: T
                                )
                              terminator: <Id.Op_Semi _>
                            )
                            (command.Sentence
                              child: 
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Exit exit>
                                  arg_word: {<1>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      ]
                    )
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:run_list)
                              op: assign_op.Equal
                              rhs: {($ Id.VSub_Number '$1')}
                              spids: [1091]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                  ]
                  spids: [1049 1050 1097 -1]
                )
                (case_arm
                  pat_list: [{<--run> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:run_list)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (braced_var_sub
                                    token: <Id.VSub_Number 1>
                                    suffix_op: 
                                      (suffix_op.Unary
                                        op_id: Id.VOp1_Pound
                                        arg_word: {<'--*='>}
                                      )
                                  )
                                }
                              spids: [1106]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                  ]
                  spids: [1100 1103 1116 -1]
                )
                (case_arm
                  pat_list: [{<-h>} {<--h>} {<--he>} {<--hel>} {<--help>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:help)
                              op: assign_op.Equal
                              rhs: {<t>}
                              spids: [1131]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                  ]
                  spids: [1119 1128 1137 -1]
                )
                (case_arm
                  pat_list: [
                    {<-v>}
                    {<--v>}
                    {<--ve>}
                    {<--ver>}
                    {<--verb>}
                    {<--verbo>}
                    {<--verbos>}
                    {<--verbose>}
                  ]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:verbose)
                              op: assign_op.Equal
                              rhs: {<t>}
                              spids: [1158]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                  ]
                  spids: [1140 1155 1164 -1]
                )
                (case_arm
                  pat_list: [{<--verbose-only> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:verbose_only)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <Id.VSub_Number 1>
                                suffix_op: (suffix_op.Unary op_id:Id.VOp1_Pound arg_word:{<'--*='>})
                              )
                            }
                          spids: [1173]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [1167 1170 1183 -1]
                )
                (case_arm
                  pat_list: [{<-q>} {<--q>} {<--qu>} {<--qui>} {<--quie>} {<--quiet>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Id.Op_DAmp]
                          children: [
                            (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$HARNESS_ACTIVE'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:quiet)
                                  op: assign_op.Equal
                                  rhs: {<t>}
                                  spids: [1218]
                                )
                              ]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                  ]
                  spids: [1186 1197 1224 -1]
                )
                (case_arm
                  pat_list: [{<--with-dashes>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:with_dashes)
                              op: assign_op.Equal
                              rhs: {<t>}
                              spids: [1231]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                  ]
                  spids: [1227 1228 1237 -1]
                )
                (case_arm
                  pat_list: [{<--no-color>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:color)
                              op: assign_op.Equal
                              rhs: (word.Empty)
                              spids: [1244]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                  ]
                  spids: [1240 1241 1249 -1]
                )
                (case_arm
                  pat_list: [
                    {<--va>}
                    {<--val>}
                    {<--valg>}
                    {<--valgr>}
                    {<--valgri>}
                    {<--valgrin>}
                    {<--valgrind>}
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:valgrind)
                          op: assign_op.Equal
                          rhs: {<memcheck>}
                          spids: [1268]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [1252 1265 1274 -1]
                )
                (case_arm
                  pat_list: [{<--valgrind> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:valgrind)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <Id.VSub_Number 1>
                                suffix_op: (suffix_op.Unary op_id:Id.VOp1_Pound arg_word:{<'--*='>})
                              )
                            }
                          spids: [1283]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [1277 1280 1293 -1]
                )
                (case_arm
                  pat_list: [{<--valgrind-only> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:valgrind_only)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <Id.VSub_Number 1>
                                suffix_op: (suffix_op.Unary op_id:Id.VOp1_Pound arg_word:{<'--*='>})
                              )
                            }
                          spids: [1302]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [1296 1299 1312 -1]
                )
                (case_arm
                  pat_list: [{<--tee>}]
                  action: [(C {<shift>})]
                  spids: [1315 1316 1321 -1]
                )
                (case_arm
                  pat_list: [{<--root> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:root)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <Id.VSub_Number 1>
                                suffix_op: (suffix_op.Unary op_id:Id.VOp1_Pound arg_word:{<'--*='>})
                              )
                            }
                          spids: [1333]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [1327 1330 1343 -1]
                )
                (case_arm
                  pat_list: [{<--chain-lint>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:GIT_TEST_CHAIN_LINT)
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [1350]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [1346 1347 1356 -1]
                )
                (case_arm
                  pat_list: [{<--no-chain-lint>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:GIT_TEST_CHAIN_LINT)
                          op: assign_op.Equal
                          rhs: {<0>}
                          spids: [1363]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [1359 1360 1369 -1]
                )
                (case_arm
                  pat_list: [{<-x>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:trace)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [1376]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:verbose)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [1380]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [1372 1373 1386 -1]
                )
                (case_arm
                  pat_list: [{<--verbose-log>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:verbose_log)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [1393]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [1389 1390 1399 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.Simple
                          words: [
                            {<echo>}
                            {(DQ <'error: unknown test option \''> ($ Id.VSub_Number '$1') <'\''>)}
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_GreatAnd '>&'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<2>}
                            )
                          ]
                          do_fork: T
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {<1>}
                    )
                  ]
                  spids: [1402 1403 1422 -1]
                )
              ]
            )
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$valgrind_only'))})]
          action: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$valgrind'))})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:valgrind)
                      op: assign_op.Equal
                      rhs: {<memcheck>}
                      spids: [1453]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$verbose'))})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:verbose_only)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$valgrind_only'))}
                      spids: [1467]
                    )
                  ]
                )
              ]
            )
          ]
          spids: [1430 1440]
        )
        (if_arm
          cond: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$valgrind'))})]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:verbose)
                  op: assign_op.Equal
                  rhs: {<t>}
                  spids: [1485]
                )
              ]
            )
          ]
          spids: [1472 1482]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$color'))})]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:say_color_error)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.CommandList
                            children: [
                              (command.Sentence
                                child: (C {<tput>} {<bold>})
                                terminator: <Id.Op_Semi _>
                              )
                              (C {<tput>} {<setaf>} {<1>})
                            ]
                          )
                      )
                    }
                  spids: [1552]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:say_color_skip)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<tput>} {<setaf>} {<4>})
                      )
                    }
                  spids: [1570]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:say_color_warn)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<tput>} {<setaf>} {<3>})
                      )
                    }
                  spids: [1583]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:say_color_pass)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<tput>} {<setaf>} {<2>})
                      )
                    }
                  spids: [1596]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:say_color_info)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<tput>} {<setaf>} {<6>})
                      )
                    }
                  spids: [1609]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:say_color_reset)
                  op: assign_op.Equal
                  rhs: {(command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<tput>} {<sgr0>}))}
                  spids: [1622]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:say_color_)
                  op: assign_op.Equal
                  rhs: {(DQ )}
                  spids: [1630]
                )
              ]
            )
            (command.ShFunction
              name: say_color
              body: 
                (BraceGroup
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DAmp]
                      children: [
                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_Number '$1'))})
                        (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$quiet'))})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                        )
                      ]
                    )
                    (C {<eval>} 
                      {
                        (DQ <'say_color_color='> 
                          (word_part.EscapedLiteral
                            token: <Id.Lit_EscapedChar '\\$'>
                          ) <say_color_> ($ Id.VSub_Number '$1')
                        )
                      }
                    )
                    (C {<shift>})
                    (C {<printf>} 
                      {(DQ <'%s'> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\\'>) <n>)} 
                      {
                        (DQ ($ Id.VSub_DollarName '$say_color_color') ($ Id.VSub_Star '$*') 
                          ($ Id.VSub_DollarName '$say_color_reset')
                        )
                      }
                    )
                  ]
                )
            )
          ]
          spids: [1491 1501]
        )
      ]
      else_action: [
        (command.ShFunction
          name: say_color
          body: 
            (BraceGroup
              children: [
                (command.AndOr
                  ops: [Id.Op_DAmp Id.Op_DAmp]
                  children: [
                    (C {<test>} {<-z>} {(DQ ($ Id.VSub_Number '$1'))})
                    (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$quiet'))})
                    (command.ControlFlow token:<Id.ControlFlow_Return return>)
                  ]
                )
                (C {<shift>})
                (C {<printf>} {(DQ <'%s'> <Id.Lit_Other '\\'> <n>)} {(DQ ($ Id.VSub_Star '$*'))})
              ]
            )
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:TERM)
          op: assign_op.Equal
          rhs: {<dumb>}
          spids: [1753]
        )
      ]
    )
    (C {<export>} {<TERM>})
    (command.ShFunction
      name: error
      body: 
        (BraceGroup
          children: [
            (C {<say_color>} {<error>} {(DQ <'error: '> ($ Id.VSub_Star '$*'))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:GIT_EXIT_OK)
                  op: assign_op.Equal
                  rhs: {<t>}
                  spids: [1779]
                )
              ]
            )
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
        )
    )
    (command.ShFunction
      name: say
      body: (BraceGroup children:[(C {<say_color>} {<info>} {(DQ ($ Id.VSub_Star '$*'))})])
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$HARNESS_ACTIVE'))})]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<test>} {(DQ ($ Id.VSub_DollarName '$verbose'))} {<Id.Lit_Equals '='>} {<t>})
                        (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$verbose_only'))})
                      ]
                    )
                  ]
                  action: [
                    (C {<printf>} {(SQ <'Bail out! %s\\n'>)} 
                      {(SQ <'verbose mode forbidden under TAP harness; try --verbose-log'>)}
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {<1>}
                    )
                  ]
                  spids: [1822 1845]
                )
              ]
            )
          ]
          spids: [1809 1819]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (C {<test>} {(DQ (${ Id.VSub_Name test_description))} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ )})
        (C {<error>} {(DQ <'Test script did not set test_description.'>)})
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {<test>} {(DQ ($ Id.VSub_DollarName '$help'))} {<Id.Lit_Equals '='>} {(DQ <t>)})]
          action: [
            (C {<printf>} {(SQ <'%s\\n'>)} {(DQ ($ Id.VSub_DollarName '$test_description'))})
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<0>})
          ]
          spids: [1894 1908]
        )
      ]
    )
    (command.Simple
      words: [{<exec>}]
      redirects: [(redir op:<Id.Redir_GreatAnd '5>&'> loc:(redir_loc.Fd fd:5) arg:{<1>})]
      do_fork: T
    )
    (command.Simple
      words: [{<exec>}]
      redirects: [(redir op:<Id.Redir_LessAnd '6<&'> loc:(redir_loc.Fd fd:6) arg:{<0>})]
      do_fork: T
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (C {<test>} {(DQ ($ Id.VSub_DollarName '$verbose_log'))} {<Id.Lit_Equals '='>} {(DQ <t>)})
          ]
          action: [
            (command.Simple
              words: [{<exec>}]
              redirects: [
                (redir
                  op: <Id.Redir_DGreat '3>>'>
                  loc: (redir_loc.Fd fd:3)
                  arg: {(DQ ($ Id.VSub_DollarName '$GIT_TEST_TEE_OUTPUT_FILE'))}
                )
                (redir op:<Id.Redir_GreatAnd '4>&'> loc:(redir_loc.Fd fd:4) arg:{<3>})
              ]
              do_fork: T
            )
          ]
          spids: [1939 1953]
        )
        (if_arm
          cond: [(C {<test>} {(DQ ($ Id.VSub_DollarName '$verbose'))} {<Id.Lit_Equals '='>} {(DQ <t>)})]
          action: [
            (command.Simple
              words: [{<exec>}]
              redirects: [
                (redir op:<Id.Redir_GreatAnd '4>&'> loc:(redir_loc.Fd fd:4) arg:{<2>})
                (redir op:<Id.Redir_GreatAnd '3>&'> loc:(redir_loc.Fd fd:3) arg:{<1>})
              ]
              do_fork: T
            )
          ]
          spids: [1966 1980]
        )
      ]
      else_action: [
        (command.Simple
          words: [{<exec>}]
          redirects: [
            (redir op:<Id.Redir_Great '4>'> loc:(redir_loc.Fd fd:4) arg:{<'/dev/null'>})
            (redir op:<Id.Redir_Great '3>'> loc:(redir_loc.Fd fd:3) arg:{<'/dev/null'>})
          ]
          do_fork: T
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:BASH_XTRACEFD)
          op: assign_op.Equal
          rhs: {<4>}
          spids: [2038]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:test_failure)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [2042]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:test_count)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [2045]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:test_fixed)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [2048]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:test_broken)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [2051]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:test_success)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [2054]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:test_external_has_tap)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [2058]
        )
      ]
    )
    (command.ShFunction
      name: die
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:code)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '$?')}
                  spids: [2070]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$GIT_EXIT_OK'))})]
                  action: [
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {($ Id.VSub_DollarName '$code')}
                    )
                  ]
                  spids: [2074 2085]
                )
              ]
              else_action: [
                (command.Simple
                  words: [
                    {<echo>}
                    {(DQ <'FATAL: Unexpected exit with code '> ($ Id.VSub_DollarName '$code'))}
                  ]
                  redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<5>})]
                  do_fork: T
                )
                (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
              ]
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:GIT_EXIT_OK)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [2117]
        )
      ]
    )
    (C {<trap>} {(SQ <die>)} {<EXIT>})
    (C {<trap>} {(SQ <'exit $?'>)} {<INT>})
    (C {<.>} {(DQ ($ Id.VSub_DollarName '$TEST_DIRECTORY') <'/test-lib-functions.sh'>)})
    (command.ShFunction
      name: test_ok_
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:test_success)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (word_part.ArithSub
                        anode: 
                          (arith_expr.Binary
                            op_id: Id.Arith_Plus
                            left: {($ Id.VSub_DollarName '$test_success')}
                            right: {<Id.Lit_Digits 1>}
                          )
                      )
                    }
                  spids: [2165]
                )
              ]
            )
            (C {<say_color>} {(DQ )} 
              {(DQ <'ok '> ($ Id.VSub_DollarName '$test_count') <' - '> ($ Id.VSub_At '$@'))}
            )
          ]
        )
    )
    (command.ShFunction
      name: test_failure_
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:test_failure)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (word_part.ArithSub
                        anode: 
                          (arith_expr.Binary
                            op_id: Id.Arith_Plus
                            left: {($ Id.VSub_DollarName '$test_failure')}
                            right: {<Id.Lit_Digits 1>}
                          )
                      )
                    }
                  spids: [2199]
                )
              ]
            )
            (C {<say_color>} {<error>} 
              {(DQ <'not ok '> ($ Id.VSub_DollarName '$test_count') <' - '> ($ Id.VSub_Number '$1'))}
            )
            (C {<shift>})
            (command.Pipeline
              children: [
                (C {<printf>} {(SQ <'%s\\n'>)} {(DQ ($ Id.VSub_Star '$*'))})
                (C {<sed>} {<-e>} {(SQ <'s/^/#\t/'>)})
              ]
              negated: F
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} {(DQ ($ Id.VSub_DollarName '$immediate'))} {<Id.Lit_Equals '='>} {(DQ )})
                (BraceGroup
                  children: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:GIT_EXIT_OK)
                              op: assign_op.Equal
                              rhs: {<t>}
                              spids: [2261]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (command.Sentence
                      child: (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: test_known_broken_ok_
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:test_fixed)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (word_part.ArithSub
                        anode: 
                          (arith_expr.Binary
                            op_id: Id.Arith_Plus
                            left: {($ Id.VSub_DollarName '$test_fixed')}
                            right: {<Id.Lit_Digits 1>}
                          )
                      )
                    }
                  spids: [2283]
                )
              ]
            )
            (C {<say_color>} {<error>} 
              {
                (DQ <'ok '> ($ Id.VSub_DollarName '$test_count') <' - '> ($ Id.VSub_At '$@') 
                  <' # TODO known breakage vanished'>
                )
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: test_known_broken_failure_
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:test_broken)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (word_part.ArithSub
                        anode: 
                          (arith_expr.Binary
                            op_id: Id.Arith_Plus
                            left: {($ Id.VSub_DollarName '$test_broken')}
                            right: {<Id.Lit_Digits 1>}
                          )
                      )
                    }
                  spids: [2315]
                )
              ]
            )
            (C {<say_color>} {<warn>} 
              {
                (DQ <'not ok '> ($ Id.VSub_DollarName '$test_count') <' - '> ($ Id.VSub_At '$@') 
                  <' # TODO known breakage'>
                )
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: test_debug
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} {(DQ ($ Id.VSub_DollarName '$debug'))} {<Id.Lit_Equals '='>} {(DQ )})
                (C {<eval>} {(DQ ($ Id.VSub_Number '$1'))})
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: match_pattern_list
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:arg)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number '$1'))}
                  spids: [2377]
                )
              ]
            )
            (C {<shift>})
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-z>} {(DQ ($ Id.VSub_Star '$*'))})
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<1>}
                )
              ]
            )
            (command.ForEach
              iter_name: pattern_
              do_arg_iter: T
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName '$arg'))}
                      arms: [
                        (case_arm
                          pat_list: [{($ Id.VSub_DollarName '$pattern_')}]
                          action: [
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<0>}
                            )
                          ]
                          spids: [2418 2419 -1 2427]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<1>})
          ]
        )
    )
    (command.ShFunction
      name: match_test_selector_list
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:title)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number '$1'))}
                  spids: [2448]
                )
              ]
            )
            (C {<shift>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:arg)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number '$1'))}
                  spids: [2457]
                )
              ]
            )
            (C {<shift>})
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-z>} {(DQ ($ Id.VSub_Number '$1'))})
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<0>}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:OLDIFS)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$IFS')}
                  spids: [2486]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:IFS)
                  op: assign_op.Equal
                  rhs: {(SQ <' \t,'>)}
                  spids: [2490]
                )
              ]
            )
            (C {<Id.KW_Set set>} {<-->} {($ Id.VSub_Number '$1')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:IFS)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$OLDIFS')}
                  spids: [2503]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:include)
                  op: assign_op.Equal
                  rhs: (word.Empty)
                  spids: [2512]
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_Number '$1'))}
              arms: [
                (case_arm
                  pat_list: [{<Id.KW_Bang '!'> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:include)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [2528]
                        )
                      ]
                    )
                  ]
                  spids: [2524 2526 2531 -1]
                )
              ]
            )
            (command.ForEach
              iter_name: selector
              do_arg_iter: T
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:orig_selector)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$selector')}
                          spids: [2546]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:positive)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [2551]
                        )
                      ]
                    )
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName '$selector'))}
                      arms: [
                        (case_arm
                          pat_list: [{<Id.KW_Bang '!'> <Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:positive)
                                  op: assign_op.Equal
                                  rhs: (word.Empty)
                                  spids: [2569]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:selector)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name selector>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VOp1_DPound
                                            arg_word: {<'?'>}
                                          )
                                      )
                                    }
                                  spids: [2572]
                                )
                              ]
                            )
                          ]
                          spids: [2564 2566 2580 -1]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$selector'))})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Continue continue>
                        )
                      ]
                    )
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName '$selector'))}
                      arms: [
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'> <-> <Id.Lit_Star '*'>}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Simple
                                      words: [
                                        {<expr>}
                                        {
                                          (DQ <z> 
                                            (braced_var_sub
                                              token: <Id.VSub_Name selector>
                                              suffix_op: 
                                                (suffix_op.Unary
                                                  op_id: Id.VOp1_DPercent
                                                  arg_word: {<'-*'>}
                                                )
                                            )
                                          )
                                        }
                                        {<Id.Lit_Colon ':'>}
                                        {(DQ <'z[0-9]*[^0-9]'>)}
                                      ]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_Great '>'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: {<'/dev/null'>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                  ]
                                  action: [
                                    (command.Simple
                                      words: [
                                        {<echo>}
                                        {
                                          (DQ <'error: '> ($ Id.VSub_DollarName '$title') 
                                            <': invalid non-numeric in range'>
                                          )
                                        }
                                        {
                                          (DQ <'start: \''> ($ Id.VSub_DollarName '$orig_selector') 
                                            <'\''>
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_GreatAnd '>&'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: {<2>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Exit exit>
                                      arg_word: {<1>}
                                    )
                                  ]
                                  spids: [2616 2639]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Simple
                                      words: [
                                        {<expr>}
                                        {
                                          (DQ <z> 
                                            (braced_var_sub
                                              token: <Id.VSub_Name selector>
                                              suffix_op: 
                                                (suffix_op.Unary
                                                  op_id: Id.VOp1_Pound
                                                  arg_word: {<'*-'>}
                                                )
                                            )
                                          )
                                        }
                                        {<Id.Lit_Colon ':'>}
                                        {(DQ <'z[0-9]*[^0-9]'>)}
                                      ]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_Great '>'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: {<'/dev/null'>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                  ]
                                  action: [
                                    (command.Simple
                                      words: [
                                        {<echo>}
                                        {
                                          (DQ <'error: '> ($ Id.VSub_DollarName '$title') 
                                            <': invalid non-numeric in range'>
                                          )
                                        }
                                        {
                                          (DQ <'end: \''> ($ Id.VSub_DollarName '$orig_selector') 
                                            <'\''>
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_GreatAnd '>&'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: {<2>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Exit exit>
                                      arg_word: {<1>}
                                    )
                                  ]
                                  spids: [2670 2693]
                                )
                              ]
                            )
                          ]
                          spids: [2610 2613 2724 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Simple
                                      words: [
                                        {<expr>}
                                        {(DQ <z> ($ Id.VSub_DollarName '$selector'))}
                                        {<Id.Lit_Colon ':'>}
                                        {(DQ <'z[0-9]*[^0-9]'>)}
                                      ]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_Great '>'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: {<'/dev/null'>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                  ]
                                  action: [
                                    (command.Simple
                                      words: [
                                        {<echo>}
                                        {
                                          (DQ <'error: '> ($ Id.VSub_DollarName '$title') 
                                            <': invalid non-numeric in test'>
                                          )
                                        }
                                        {
                                          (DQ <'selector: \''> ($ Id.VSub_DollarName '$orig_selector') 
                                            <'\''>
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_GreatAnd '>&'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: {<2>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Exit exit>
                                      arg_word: {<1>}
                                    )
                                  ]
                                  spids: [2731 2750]
                                )
                              ]
                            )
                          ]
                          spids: [2727 2728 -1 2781]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DAmp]
                      children: [
                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$include'))})
                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$positive'))})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Continue continue>
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DAmp]
                      children: [
                        (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$include'))})
                        (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$positive'))})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Continue continue>
                        )
                      ]
                    )
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName '$selector'))}
                      arms: [
                        (case_arm
                          pat_list: [{<-> <Id.Lit_Star '*'>}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (C {<test>} {($ Id.VSub_DollarName '$arg')} {<-le>} 
                                      {
                                        (braced_var_sub
                                          token: <Id.VSub_Name selector>
                                          suffix_op: 
                                            (suffix_op.Unary
                                              op_id: Id.VOp1_Pound
                                              arg_word: {<->}
                                            )
                                        )
                                      }
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:include)
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_DollarName '$positive')}
                                          spids: [2868]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [2850 2865]
                                )
                              ]
                            )
                          ]
                          spids: [2845 2847 2875 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'> <->}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (C {<test>} {($ Id.VSub_DollarName '$arg')} {<-ge>} 
                                      {
                                        (braced_var_sub
                                          token: <Id.VSub_Name selector>
                                          suffix_op: 
                                            (suffix_op.Unary
                                              op_id: Id.VOp1_Percent
                                              arg_word: {<->}
                                            )
                                        )
                                      }
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:include)
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_DollarName '$positive')}
                                          spids: [2901]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [2883 2898]
                                )
                              ]
                            )
                          ]
                          spids: [2878 2880 2908 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'> <-> <Id.Lit_Star '*'>}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.AndOr
                                      ops: [Id.Op_DAmp]
                                      children: [
                                        (C {<test>} 
                                          {
                                            (braced_var_sub
                                              token: <Id.VSub_Name selector>
                                              suffix_op: 
                                                (suffix_op.Unary
                                                  op_id: Id.VOp1_DPercent
                                                  arg_word: {<'-*'>}
                                                )
                                            )
                                          } {<-le>} {($ Id.VSub_DollarName '$arg')}
                                        )
                                        (C {<test>} {($ Id.VSub_DollarName '$arg')} {<-le>} 
                                          {
                                            (braced_var_sub
                                              token: <Id.VSub_Name selector>
                                              suffix_op: 
                                                (suffix_op.Unary
                                                  op_id: Id.VOp1_Pound
                                                  arg_word: {<'*-'>}
                                                )
                                            )
                                          }
                                        )
                                      ]
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:include)
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_DollarName '$positive')}
                                          spids: [2951]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [2917 2948]
                                )
                              ]
                            )
                          ]
                          spids: [2911 2914 2958 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (C {<test>} {($ Id.VSub_DollarName '$arg')} {<-eq>} 
                                      {($ Id.VSub_DollarName '$selector')}
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:include)
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_DollarName '$positive')}
                                          spids: [2979]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [2965 2976]
                                )
                              ]
                            )
                          ]
                          spids: [2961 2962 2986 -1]
                        )
                      ]
                    )
                  ]
                )
            )
            (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$include'))})
          ]
        )
    )
    (command.ShFunction
      name: maybe_teardown_verbose
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$verbose_only'))})
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.Simple
              words: [{<exec>}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '4>'>
                  loc: (redir_loc.Fd fd:4)
                  arg: {<'/dev/null'>}
                )
                (redir
                  op: <Id.Redir_Great '3>'>
                  loc: (redir_loc.Fd fd:3)
                  arg: {<'/dev/null'>}
                )
              ]
              do_fork: T
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:verbose)
                  op: assign_op.Equal
                  rhs: (word.Empty)
                  spids: [3037]
                )
              ]
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:last_verbose)
          op: assign_op.Equal
          rhs: {<t>}
          spids: [3042]
        )
      ]
    )
    (command.ShFunction
      name: maybe_setup_verbose
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$verbose_only'))})
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {<match_pattern_list>} {($ Id.VSub_DollarName '$test_count')} 
                      {($ Id.VSub_DollarName '$verbose_only')}
                    )
                  ]
                  action: [
                    (command.Simple
                      words: [{<exec>}]
                      redirects: [
                        (redir
                          op: <Id.Redir_GreatAnd '4>&'>
                          loc: (redir_loc.Fd fd:4)
                          arg: {<2>}
                        )
                        (redir
                          op: <Id.Redir_GreatAnd '3>&'>
                          loc: (redir_loc.Fd fd:3)
                          arg: {<1>}
                        )
                      ]
                      do_fork: T
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$last_verbose'))})
                        (command.Simple
                          words: [{<echo>} {(DQ )}]
                          redirects: [
                            (redir
                              op: <Id.Redir_GreatAnd '>&'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<3>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:verbose)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [3126]
                        )
                      ]
                    )
                  ]
                  spids: [3066 3075]
                )
              ]
              else_action: [
                (command.Simple
                  words: [{<exec>}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '4>'>
                      loc: (redir_loc.Fd fd:4)
                      arg: {<'/dev/null'>}
                    )
                    (redir
                      op: <Id.Redir_Great '3>'>
                      loc: (redir_loc.Fd fd:3)
                      arg: {<'/dev/null'>}
                    )
                  ]
                  do_fork: T
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:verbose)
                      op: assign_op.Equal
                      rhs: (word.Empty)
                      spids: [3142]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:last_verbose)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$verbose')}
                  spids: [3148]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: maybe_teardown_valgrind
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$GIT_VALGRIND'))})
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:GIT_VALGRIND_ENABLED)
                  op: assign_op.Equal
                  rhs: (word.Empty)
                  spids: [3175]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: maybe_setup_valgrind
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$GIT_VALGRIND'))})
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$valgrind_only'))})]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:GIT_VALGRIND_ENABLED)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [3215]
                        )
                      ]
                    )
                    (command.ControlFlow token:<Id.ControlFlow_Return return>)
                  ]
                  spids: [3201 3212]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:GIT_VALGRIND_ENABLED)
                  op: assign_op.Equal
                  rhs: (word.Empty)
                  spids: [3225]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {<match_pattern_list>} {($ Id.VSub_DollarName '$test_count')} 
                      {($ Id.VSub_DollarName '$valgrind_only')}
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:GIT_VALGRIND_ENABLED)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [3240]
                        )
                      ]
                    )
                  ]
                  spids: [3228 3237]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: want_trace
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {(DQ ($ Id.VSub_DollarName '$trace'))} {<Id.Lit_Equals '='>} {<t>})
                (C {<test>} {(DQ ($ Id.VSub_DollarName '$verbose'))} {<Id.Lit_Equals '='>} {<t>})
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: test_eval_inner_
      body: 
        (BraceGroup
          children: [
            (C {<eval>} {(DQ <'\n'> <'\t\twant_trace && set -x\n'> <'\t\t'> ($ Id.VSub_Star '$*'))})
          ]
        )
    )
    (command.ShFunction
      name: test_eval_
      body: 
        (BraceGroup
          children: [
            (BraceGroup
              children: [
                (command.Simple
                  words: [{<test_eval_inner_>} {(DQ ($ Id.VSub_At '$@'))}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Less '<'>
                      loc: (redir_loc.Fd fd:0)
                      arg: {<'/dev/null'>}
                    )
                    (redir
                      op: <Id.Redir_GreatAnd '>&'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<3>}
                    )
                    (redir
                      op: <Id.Redir_GreatAnd '2>&'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<4>}
                    )
                  ]
                  do_fork: T
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:test_eval_ret_)
                      op: assign_op.Equal
                      rhs: {($ Id.VSub_QMark '$?')}
                      spids: [3377]
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: [(C {<want_trace>})]
                      action: [
                        (C {<Id.KW_Set set>} {<Id.Lit_Other '+'> <x>})
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (C {<test>} {(DQ ($ Id.VSub_DollarName '$test_eval_ret_'))} 
                                  {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<0>}
                                )
                              ]
                              action: [
                                (command.Simple
                                  words: [
                                    {<say_color>}
                                    {<error>}
                                    {
                                      (DQ <'error: last command exited with '> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\$'>
                                        ) <'?='> ($ Id.VSub_DollarName '$test_eval_ret_')
                                      )
                                    }
                                  ]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_GreatAnd '>&'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {<4>}
                                    )
                                  ]
                                  do_fork: T
                                )
                              ]
                              spids: [3395 3409]
                            )
                          ]
                        )
                      ]
                      spids: [3381 3386]
                    )
                  ]
                )
              ]
              redirects: [(redir op:<Id.Redir_Great '2>'> loc:(redir_loc.Fd fd:2) arg:{<'/dev/null'>})]
            )
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {($ Id.VSub_DollarName '$test_eval_ret_')}
            )
          ]
        )
    )
    (command.ShFunction
      name: test_run_
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:test_cleanup)
                  op: assign_op.Equal
                  rhs: {<Id.Lit_Colon ':'>}
                  spids: [3454]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:expecting_failure)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$2')}
                  spids: [3458]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {<test>} 
                          {
                            (DQ 
                              (braced_var_sub
                                token: <Id.VSub_Name GIT_TEST_CHAIN_LINT>
                                suffix_op: (suffix_op.Unary op_id:Id.VTest_ColonHyphen arg_word:{<1>})
                              )
                            )
                          } {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<0>}
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:trace_tmp)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$trace')}
                          spids: [3492]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:trace)
                          op: assign_op.Equal
                          rhs: (word.Empty)
                          spids: [3496]
                        )
                      ]
                    )
                    (C {<test_eval_>} {(DQ <'(exit 117) && '> ($ Id.VSub_Number '$1'))})
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {<test>} {(DQ ($ Id.VSub_QMark '$?'))} 
                                  {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<117>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          action: [
                            (C {<error>} 
                              {
                                (DQ <'bug in the test script: broken &&-chain: '> 
                                  ($ Id.VSub_Number '$1')
                                )
                              }
                            )
                          ]
                          spids: [3515 3529]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:trace)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$trace_tmp')}
                          spids: [3543]
                        )
                      ]
                    )
                  ]
                  spids: [3463 3481]
                )
              ]
            )
            (C {<setup_malloc_check>})
            (C {<test_eval_>} {(DQ ($ Id.VSub_Number '$1'))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:eval_ret)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '$?')}
                  spids: [3561]
                )
              ]
            )
            (C {<teardown_malloc_check>})
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Id.Op_DPipe Id.Op_DPipe Id.Op_DAmp]
                      children: [
                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$immediate'))})
                        (C {<test>} {($ Id.VSub_DollarName '$eval_ret')} {<Id.Lit_Equals '='>} {<0>})
                        (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$expecting_failure'))})
                        (C {<test>} {(DQ ($ Id.VSub_DollarName '$test_cleanup'))} 
                          {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ <':'>)}
                        )
                      ]
                    )
                  ]
                  action: [
                    (C {<setup_malloc_check>})
                    (C {<test_eval_>} {(DQ ($ Id.VSub_DollarName '$test_cleanup'))})
                    (C {<teardown_malloc_check>})
                  ]
                  spids: [3569 3616]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<test>} {(DQ ($ Id.VSub_DollarName '$verbose'))} {<Id.Lit_Equals '='>} 
                          {(DQ <t>)}
                        )
                        (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$HARNESS_ACTIVE'))})
                      ]
                    )
                  ]
                  action: [(C {<echo>} {(DQ )})]
                  spids: [3635 3660]
                )
              ]
            )
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {(DQ ($ Id.VSub_DollarName '$eval_ret'))}
            )
          ]
        )
    )
    (command.ShFunction
      name: test_start_
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:test_count)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (word_part.ArithSub
                        anode: 
                          (arith_expr.Binary
                            op_id: Id.Arith_Plus
                            left: {($ Id.VSub_DollarName '$test_count')}
                            right: {<Id.Lit_Digits 1>}
                          )
                      )
                    }
                  spids: [3689]
                )
              ]
            )
            (C {<maybe_setup_verbose>})
            (C {<maybe_setup_valgrind>})
          ]
        )
    )
    (command.ShFunction
      name: test_finish_
      body: 
        (BraceGroup
          children: [
            (command.Simple
              words: [{<echo>} {(DQ )}]
              redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<3>})]
              do_fork: T
            )
            (C {<maybe_teardown_valgrind>})
            (C {<maybe_teardown_verbose>})
          ]
        )
    )
    (command.ShFunction
      name: test_skip
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:to_skip)
                  op: assign_op.Equal
                  rhs: (word.Empty)
                  spids: [3739]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:skipped_reason)
                  op: assign_op.Equal
                  rhs: (word.Empty)
                  spids: [3742]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {<match_pattern_list>} 
                      {($ Id.VSub_DollarName '$this_test') <.> ($ Id.VSub_DollarName '$test_count')} {($ Id.VSub_DollarName '$GIT_SKIP_TESTS')}
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:to_skip)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [3759]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:skipped_reason)
                          op: assign_op.Equal
                          rhs: {(DQ <GIT_SKIP_TESTS>)}
                          spids: [3763]
                        )
                      ]
                    )
                  ]
                  spids: [3745 3756]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DAmp]
                      children: [
                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$to_skip'))})
                        (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$test_prereq'))})
                        (command.Pipeline
                          children: [
                            (C {<test_have_prereq>} {(DQ ($ Id.VSub_DollarName '$test_prereq'))})
                          ]
                          negated: T
                        )
                      ]
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:to_skip)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [3807]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:of_prereq)
                          op: assign_op.Equal
                          rhs: (word.Empty)
                          spids: [3812]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (C {<test>} {(DQ ($ Id.VSub_DollarName '$missing_prereq'))} 
                              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ ($ Id.VSub_DollarName '$test_prereq'))}
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:of_prereq)
                                  op: assign_op.Equal
                                  rhs: {(DQ <' of '> ($ Id.VSub_DollarName '$test_prereq'))}
                                  spids: [3834]
                                )
                              ]
                            )
                          ]
                          spids: [3815 3831]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:skipped_reason)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ <'missing '> ($ Id.VSub_DollarName '$missing_prereq') 
                                (${ Id.VSub_Name of_prereq)
                              )
                            }
                          spids: [3844]
                        )
                      ]
                    )
                  ]
                  spids: [3772 3804]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DAmp]
                      children: [
                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$to_skip'))})
                        (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$run_list'))})
                        (command.Pipeline
                          children: [
                            (C {<match_test_selector_list>} {(SQ <--run>)} 
                              {($ Id.VSub_DollarName '$test_count')} {(DQ ($ Id.VSub_DollarName '$run_list'))}
                            )
                          ]
                          negated: T
                        )
                      ]
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:to_skip)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [3898]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:skipped_reason)
                          op: assign_op.Equal
                          rhs: {(DQ <--run>)}
                          spids: [3902]
                        )
                      ]
                    )
                  ]
                  spids: [3857 3895]
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$to_skip'))}
              arms: [
                (case_arm
                  pat_list: [{<t>}]
                  action: [
                    (command.Simple
                      words: [{<say_color>} {<skip>} {(DQ <'skipping test: '> ($ Id.VSub_At '$@'))}]
                      redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<3>})]
                      do_fork: T
                    )
                    (C {<say_color>} {<skip>} 
                      {
                        (DQ <'ok '> ($ Id.VSub_DollarName '$test_count') <' # skip '> 
                          ($ Id.VSub_Number '$1') <' ('> ($ Id.VSub_DollarName '$skipped_reason') <')'>
                        )
                      }
                    )
                    (C {<Id.Lit_Colon ':'>} {<true>})
                  ]
                  spids: [3921 3922 3958 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [(C {<false>})]
                  spids: [3961 3962 3968 -1]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: test_at_end_hook_
      body: (BraceGroup children:[(C {<Id.Lit_Colon ':'>})])
    )
    (command.ShFunction
      name: test_done
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:GIT_EXIT_OK)
                  op: assign_op.Equal
                  rhs: {<t>}
                  spids: [4000]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$HARNESS_ACTIVE'))})]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:test_results_dir)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$TEST_OUTPUT_DIRECTORY') <'/test-results'>)}
                          spids: [4019]
                        )
                      ]
                    )
                    (C {<mkdir>} {<-p>} {(DQ ($ Id.VSub_DollarName '$test_results_dir'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:base)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <Id.VSub_Number 0>
                                suffix_op: 
                                  (suffix_op.Unary
                                    op_id: Id.VOp1_DPound
                                    arg_word: {<'*'> <Id.Lit_Slash '/'>}
                                  )
                              )
                            }
                          spids: [4035]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:test_results_path)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ ($ Id.VSub_DollarName '$test_results_dir') <'/'> 
                                (braced_var_sub
                                  token: <Id.VSub_Name base>
                                  suffix_op: (suffix_op.Unary op_id:Id.VOp1_Percent arg_word:{<.sh>})
                                ) <.counts>
                              )
                            }
                          spids: [4044]
                        )
                      ]
                    )
                    (command.Simple
                      words: [{<cat>}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName '$test_results_path'))}
                        )
                        (redir
                          op: <Id.Redir_DLessDash '<<-'>
                          loc: (redir_loc.Fd fd:0)
                          arg: 
                            (redir_param.MultiLine
                              here_begin: {<EOF>}
                              here_end_span_id: 4085
                              stdin_parts: [
                                <'total '>
                                ($ Id.VSub_DollarName '$test_count')
                                <'\n'>
                                <'success '>
                                ($ Id.VSub_DollarName '$test_success')
                                <'\n'>
                                <'fixed '>
                                ($ Id.VSub_DollarName '$test_fixed')
                                <'\n'>
                                <'broken '>
                                ($ Id.VSub_DollarName '$test_broken')
                                <'\n'>
                                <'failed '>
                                ($ Id.VSub_DollarName '$test_failure')
                                <'\n'>
                                <'\n'>
                              ]
                            )
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  spids: [4005 4016]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {<test>} {(DQ ($ Id.VSub_DollarName '$test_fixed'))} 
                      {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<0>}
                    )
                  ]
                  action: [
                    (C {<say_color>} {<error>} 
                      {
                        (DQ <'# '> ($ Id.VSub_DollarName '$test_fixed') 
                          <' known breakage(s) vanished; please update test(s)'>
                        )
                      }
                    )
                  ]
                  spids: [4091 4105]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {<test>} {(DQ ($ Id.VSub_DollarName '$test_broken'))} 
                      {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<0>}
                    )
                  ]
                  action: [
                    (C {<say_color>} {<warn>} 
                      {
                        (DQ <'# still have '> ($ Id.VSub_DollarName '$test_broken') 
                          <' known breakage(s)'>
                        )
                      }
                    )
                  ]
                  spids: [4122 4136]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<test>} {(DQ ($ Id.VSub_DollarName '$test_broken'))} 
                          {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<0>}
                        )
                        (C {<test>} {(DQ ($ Id.VSub_DollarName '$test_fixed'))} 
                          {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<0>}
                        )
                      ]
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:test_remaining)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (word_part.ArithSub
                                anode: 
                                  (arith_expr.Binary
                                    op_id: Id.Arith_Minus
                                    left: 
                                      (arith_expr.Binary
                                        op_id: Id.Arith_Minus
                                        left: {($ Id.VSub_DollarName '$test_count')}
                                        right: {($ Id.VSub_DollarName '$test_broken')}
                                      )
                                    right: {($ Id.VSub_DollarName '$test_fixed')}
                                  )
                              )
                            }
                          spids: [4183]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:msg)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ <'remaining '> ($ Id.VSub_DollarName '$test_remaining') <' test(s)'>)
                            }
                          spids: [4200]
                        )
                      ]
                    )
                  ]
                  spids: [4153 4180]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:test_remaining)
                      op: assign_op.Equal
                      rhs: {($ Id.VSub_DollarName '$test_count')}
                      spids: [4211]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:msg)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$test_count') <' test(s)'>)}
                      spids: [4215]
                    )
                  ]
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$test_failure'))}
              arms: [
                (case_arm
                  pat_list: [{<0>}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$skip_all'))})
                                (C {<test>} {($ Id.VSub_DollarName '$test_count')} {<-gt>} {<0>})
                              ]
                            )
                          ]
                          action: [(C {<error>} {(DQ <'Can\'t use skip_all after running some tests'>)})]
                          spids: [4242 4263]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$skip_all'))})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:skip_all)
                              op: assign_op.Equal
                              rhs: {(DQ <' # SKIP '> ($ Id.VSub_DollarName '$skip_all'))}
                              spids: [4286]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (C {<test>} {($ Id.VSub_DollarName '$test_external_has_tap')} {<-eq>} {<0>})
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (C {<test>} {($ Id.VSub_DollarName '$test_remaining')} {<-gt>} {<0>})
                                  ]
                                  action: [
                                    (C {<say_color>} {<Id.KW_Pass pass>} 
                                      {(DQ <'# passed all '> ($ Id.VSub_DollarName '$msg'))}
                                    )
                                  ]
                                  spids: [4308 4319]
                                )
                              ]
                            )
                            (C {<say>} 
                              {
                                (DQ <1..> ($ Id.VSub_DollarName '$test_count') 
                                  ($ Id.VSub_DollarName '$skip_all')
                                )
                              }
                            )
                          ]
                          spids: [4294 4305]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DAmp]
                      children: [
                        (C {<test>} {<-d>} {(DQ ($ Id.VSub_DollarName '$remove_trash'))})
                        (C {<cd>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<dirname>} {(DQ ($ Id.VSub_DollarName '$remove_trash'))})
                              )
                            )
                          }
                        )
                        (C {<rm>} {<-rf>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<basename>} {(DQ ($ Id.VSub_DollarName '$remove_trash'))})
                              )
                            )
                          }
                        )
                      ]
                    )
                    (C {<test_at_end_hook_>})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [4234 4235 4398 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (C {<test>} {($ Id.VSub_DollarName '$test_external_has_tap')} {<-eq>} {<0>})
                          ]
                          action: [
                            (C {<say_color>} {<error>} 
                              {
                                (DQ <'# failed '> ($ Id.VSub_DollarName '$test_failure') <' among '> 
                                  ($ Id.VSub_DollarName '$msg')
                                )
                              }
                            )
                            (C {<say>} {(DQ <1..> ($ Id.VSub_DollarName '$test_count'))})
                          ]
                          spids: [4406 4417]
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {<1>}
                    )
                  ]
                  spids: [4402 4403 4448 -1]
                )
              ]
            )
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$valgrind'))})]
          action: [
            (command.ShFunction
              name: make_symlink
              body: 
                (BraceGroup
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DPipe]
                      children: [
                        (C {<test>} {<-h>} {(DQ ($ Id.VSub_Number '$2'))})
                        (C {<test>} {(DQ ($ Id.VSub_Number '$1'))} {<Id.Lit_Equals '='>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<readlink>} {(DQ ($ Id.VSub_Number '$2'))})
                              )
                            )
                          }
                        )
                        (BraceGroup
                          children: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [(C {<mkdir>} {(DQ ($ Id.VSub_Number '$2')) <.lock>})]
                                  action: [
                                    (command.AndOr
                                      ops: [Id.Op_DAmp Id.Op_DAmp]
                                      children: [
                                        (C {<rm>} {<-f>} {(DQ ($ Id.VSub_Number '$2'))})
                                        (C {<ln>} {<-s>} {(DQ ($ Id.VSub_Number '$1'))} 
                                          {(DQ ($ Id.VSub_Number '$2'))}
                                        )
                                        (C {<rm>} {<-r>} {(DQ ($ Id.VSub_Number '$2')) <.lock>})
                                      ]
                                    )
                                  ]
                                  spids: [4516 4526]
                                )
                              ]
                              else_action: [
                                (command.WhileUntil
                                  keyword: <Id.KW_While while>
                                  cond: [(C {<test>} {<-d>} {(DQ ($ Id.VSub_Number '$2')) <.lock>})]
                                  body: 
                                    (command.DoGroup
                                      children: [
                                        (C {<say>} 
                                          {(DQ <'Waiting for lock on '> ($ Id.VSub_Number '$2') <.>)}
                                        )
                                        (C {<sleep>} {<1>})
                                      ]
                                    )
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ShFunction
              name: make_valgrind_symlink
              body: 
                (BraceGroup
                  children: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Id.Op_DPipe Id.Op_DPipe]
                          children: [
                            (C {<test>} {<-x>} {(DQ ($ Id.VSub_Number '$1'))})
                            (C {<test>} {(DQ <'# '>)} {<Id.Lit_Equals '='>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (command.Simple
                                        words: [{<head>} {<-c>} {<2>}]
                                        redirects: [
                                          (redir
                                            op: <Id.Redir_Less '<'>
                                            loc: (redir_loc.Fd fd:0)
                                            arg: {(DQ ($ Id.VSub_Number '$1'))}
                                          )
                                        ]
                                        do_fork: T
                                      )
                                  )
                                )
                              }
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:base)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<basename>} {(DQ ($ Id.VSub_Number '$1'))})
                              )
                            }
                          spids: [4668]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:symlink_target)
                          op: assign_op.Equal
                          rhs: 
                            {($ Id.VSub_DollarName '$GIT_BUILD_DIR') <'/'> 
                              ($ Id.VSub_DollarName '$base')
                            }
                          spids: [4678]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.AndOr
                              ops: [Id.Op_DAmp Id.Op_DAmp]
                              children: [
                                (C {<test>} {<-x>} {(DQ ($ Id.VSub_DollarName '$symlink_target'))})
                                (C {<test>} {<Id.KW_Bang '!'>} {<-d>} 
                                  {(DQ ($ Id.VSub_DollarName '$symlink_target'))}
                                )
                                (C {<test>} {(DQ <'#!'>)} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} 
                                  {
                                    (DQ 
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (command.Simple
                                            words: [{<head>} {<-c>} {<2>}]
                                            redirects: [
                                              (redir
                                                op: <Id.Redir_Less '<'>
                                                loc: (redir_loc.Fd fd:0)
                                                arg: {(DQ ($ Id.VSub_DollarName '$symlink_target'))}
                                              )
                                            ]
                                            do_fork: T
                                          )
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:symlink_target)
                                  op: assign_op.Equal
                                  rhs: {<'../valgrind.sh'>}
                                  spids: [4743]
                                )
                              ]
                            )
                          ]
                          spids: [4688 4740]
                        )
                      ]
                    )
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName '$base'))}
                      arms: [
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'> <.sh>} {<Id.Lit_Star '*'> <.perl>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:symlink_target)
                                  op: assign_op.Equal
                                  rhs: {<'../unprocessed-script'>}
                                  spids: [4767]
                                )
                              ]
                            )
                          ]
                          spids: [4759 4764 -1 4771]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<make_symlink>} {(DQ ($ Id.VSub_DollarName '$symlink_target'))} 
                          {
                            (DQ ($ Id.VSub_DollarName '$GIT_VALGRIND') <'/bin/'> 
                              ($ Id.VSub_DollarName '$base')
                            )
                          }
                        )
                        (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
                      ]
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:GIT_VALGRIND)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$TEST_DIRECTORY') <'/valgrind'>}
                  spids: [4803]
                )
              ]
            )
            (C {<mkdir>} {<-p>} {(DQ ($ Id.VSub_DollarName '$GIT_VALGRIND')) <'/bin'>})
            (command.ForEach
              iter_name: file
              iter_words: [
                {($ Id.VSub_DollarName '$GIT_BUILD_DIR') <'/git'> <Id.Lit_Star '*'>}
                {($ Id.VSub_DollarName '$GIT_BUILD_DIR') <'/t/helper/test-'> <Id.Lit_Star '*'>}
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [(C {<make_valgrind_symlink>} {($ Id.VSub_DollarName '$file')})]
                )
            )
            (C {<make_symlink>} {(DQ ($ Id.VSub_DollarName '$GIT_BUILD_DIR')) <'/mergetools'>} 
              {(DQ ($ Id.VSub_DollarName '$GIT_VALGRIND') <'/bin/mergetools'>)}
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:OLDIFS)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$IFS')}
                  spids: [4861]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:IFS)
                  op: assign_op.Equal
                  rhs: {<Id.Lit_Colon ':'>}
                  spids: [4865]
                )
              ]
            )
            (command.ForEach
              iter_name: path
              iter_words: [{($ Id.VSub_DollarName '$PATH')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Pipeline
                      children: [
                        (command.Simple
                          words: [
                            {<ls>}
                            {(DQ ($ Id.VSub_DollarName '$path')) <'/git-'> <Id.Lit_Star '*'>}
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '2>'>
                              loc: (redir_loc.Fd fd:2)
                              arg: {<'/dev/null'>}
                            )
                          ]
                          do_fork: T
                        )
                        (command.WhileUntil
                          keyword: <Id.KW_While while>
                          cond: [(C {<read>} {<file>})]
                          body: 
                            (command.DoGroup
                              children: [
                                (C {<make_valgrind_symlink>} {(DQ ($ Id.VSub_DollarName '$file'))})
                              ]
                            )
                        )
                      ]
                      negated: F
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:IFS)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$OLDIFS')}
                  spids: [4919]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:PATH)
                  op: assign_op.Equal
                  rhs: 
                    {($ Id.VSub_DollarName '$GIT_VALGRIND') <'/bin'> <Id.Lit_Colon ':'> 
                      ($ Id.VSub_DollarName '$PATH')
                    }
                  spids: [4923]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:GIT_EXEC_PATH)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$GIT_VALGRIND') <'/bin'>}
                  spids: [4930]
                )
              ]
            )
            (C {<export>} {<GIT_VALGRIND>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:GIT_VALGRIND_MODE)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$valgrind'))}
                  spids: [4940]
                )
              ]
            )
            (C {<export>} {<GIT_VALGRIND_MODE>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:GIT_VALGRIND_ENABLED)
                  op: assign_op.Equal
                  rhs: {<t>}
                  spids: [4951]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$valgrind_only'))})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:GIT_VALGRIND_ENABLED)
                      op: assign_op.Equal
                      rhs: (word.Empty)
                      spids: [4965]
                    )
                  ]
                )
              ]
            )
            (C {<export>} {<GIT_VALGRIND_ENABLED>})
          ]
          spids: [4457 4467]
        )
        (if_arm
          cond: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$GIT_TEST_INSTALLED'))})]
          action: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:GIT_EXEC_PATH)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {($ Id.VSub_DollarName '$GIT_TEST_INSTALLED') <'/git'>} 
                                {<--exec-path>}
                              )
                          )
                        }
                      spids: [4985]
                    )
                  ]
                )
                (C {<error>} 
                  {(DQ <'Cannot run git from '> ($ Id.VSub_DollarName '$GIT_TEST_INSTALLED') <.>)}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:PATH)
                  op: assign_op.Equal
                  rhs: 
                    {($ Id.VSub_DollarName '$GIT_TEST_INSTALLED') <Id.Lit_Colon ':'> 
                      ($ Id.VSub_DollarName '$GIT_BUILD_DIR') <Id.Lit_Colon ':'> ($ Id.VSub_DollarName '$PATH')
                    }
                  spids: [5005]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:GIT_EXEC_PATH)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name GIT_TEST_EXEC_PATH>
                        suffix_op: 
                          (suffix_op.Unary
                            op_id: Id.VTest_ColonHyphen
                            arg_word: {($ Id.VSub_DollarName '$GIT_EXEC_PATH')}
                          )
                      )
                    }
                  spids: [5013]
                )
              ]
            )
          ]
          spids: [4972 4982]
        )
      ]
      else_action: [
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:git_bin_dir)
              op: assign_op.Equal
              rhs: {(DQ ($ Id.VSub_DollarName '$GIT_BUILD_DIR') <'/bin-wrappers'>)}
              spids: [5026]
            )
          ]
        )
        (command.If
          arms: [
            (if_arm
              cond: [
                (command.Pipeline
                  children: [(C {<test>} {<-x>} {(DQ ($ Id.VSub_DollarName '$git_bin_dir') <'/git'>)})]
                  negated: T
                )
              ]
              action: [
                (command.If
                  arms: [
                    (if_arm
                      cond: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$with_dashes'))})]
                      action: [
                        (C {<say>} 
                          {
                            (DQ ($ Id.VSub_DollarName '$git_bin_dir') 
                              <'/git is not executable; using GIT_EXEC_PATH'>
                            )
                          }
                        )
                      ]
                      spids: [5050 5061]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:with_dashes)
                      op: assign_op.Equal
                      rhs: {<t>}
                      spids: [5075]
                    )
                  ]
                )
              ]
              spids: [5033 5047]
            )
          ]
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:PATH)
              op: assign_op.Equal
              rhs: {(DQ ($ Id.VSub_DollarName '$git_bin_dir') <':'> ($ Id.VSub_DollarName '$PATH'))}
              spids: [5082]
            )
          ]
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:GIT_EXEC_PATH)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$GIT_BUILD_DIR')}
              spids: [5090]
            )
          ]
        )
        (command.If
          arms: [
            (if_arm
              cond: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$with_dashes'))})]
              action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:PATH)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ ($ Id.VSub_DollarName '$GIT_BUILD_DIR') <':'> 
                            ($ Id.VSub_DollarName '$PATH')
                          )
                        }
                      spids: [5108]
                    )
                  ]
                )
              ]
              spids: [5094 5105]
            )
          ]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:GIT_TEMPLATE_DIR)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$GIT_BUILD_DIR')) <'/templates/blt'>}
          spids: [5120]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:GIT_CONFIG_NOSYSTEM)
          op: assign_op.Equal
          rhs: {<1>}
          spids: [5126]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:GIT_ATTR_NOSYSTEM)
          op: assign_op.Equal
          rhs: {<1>}
          spids: [5129]
        )
      ]
    )
    (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 ($ Id.VSub_DollarName '$GIT_TEST_CMP'))})]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$GIT_TEST_CMP_USE_COPIED_CONTEXT'))})
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:GIT_TEST_CMP)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$DIFF') <' -c'>)}
                          spids: [5172]
                        )
                      ]
                    )
                  ]
                  spids: [5158 5169]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:GIT_TEST_CMP)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$DIFF') <' -u'>)}
                      spids: [5182]
                    )
                  ]
                )
              ]
            )
          ]
          spids: [5145 5155]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:GITPERLLIB)
          op: assign_op.Equal
          rhs: 
            {(DQ ($ Id.VSub_DollarName '$GIT_BUILD_DIR')) <'/perl/blib/lib'> <Id.Lit_Colon ':'> 
              (DQ ($ Id.VSub_DollarName '$GIT_BUILD_DIR')) <'/perl/blib/arch/auto/Git'>
            }
          spids: [5194]
        )
      ]
    )
    (C {<export>} {<GITPERLLIB>})
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (C {<test>} {<-d>} {(DQ ($ Id.VSub_DollarName '$GIT_BUILD_DIR')) <'/templates/blt'>})
        (BraceGroup
          children: [(C {<error>} {(DQ <'You haven\'t built things yet, have you?'>)})]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Pipeline
              children: [
                (C {<test>} {<-x>} 
                  {(DQ ($ Id.VSub_DollarName '$GIT_BUILD_DIR')) <'/t/helper/test-chmtime'>}
                )
              ]
              negated: T
            )
          ]
          action: [
            (command.Simple
              words: [{<echo>} {(SQ <'You need to build test-chmtime:'>)}]
              redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
              do_fork: T
            )
            (command.Simple
              words: [
                {<echo>}
                {(SQ <'Run "make t/helper/test-chmtime" in the source (toplevel) directory'>)}
              ]
              redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
              do_fork: T
            )
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
          spids: [5232 5245]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:TRASH_DIRECTORY)
          op: assign_op.Equal
          rhs: 
            {
              (DQ <'trash directory.'> 
                (command_sub
                  left_token: <Id.Left_DollarParen '$('>
                  child: (C {<basename>} {(DQ ($ Id.VSub_Number '$0'))} {<.sh>})
                )
              )
            }
          spids: [5278]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$root'))})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:TRASH_DIRECTORY)
              op: assign_op.Equal
              rhs: 
                {(DQ ($ Id.VSub_DollarName '$root') <'/'> ($ Id.VSub_DollarName '$TRASH_DIRECTORY'))}
              spids: [5302]
            )
          ]
        )
      ]
    )
    (command.Case
      to_match: {(DQ ($ Id.VSub_DollarName '$TRASH_DIRECTORY'))}
      arms: [
        (case_arm pat_list:[{<'/'> <Id.Lit_Star '*'>}] spids:[5317 5319 5321 -1])
        (case_arm
          pat_list: [{<Id.Lit_Star '*'>}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:TRASH_DIRECTORY)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ ($ Id.VSub_DollarName '$TEST_OUTPUT_DIRECTORY') <'/'> 
                        ($ Id.VSub_DollarName '$TRASH_DIRECTORY')
                      )
                    }
                  spids: [5330]
                )
              ]
            )
          ]
          spids: [5327 5328 5337 -1]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (C {<test>} {<Id.KW_Bang '!'>} {<-z>} {(DQ ($ Id.VSub_DollarName '$debug'))})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:remove_trash)
              op: assign_op.Equal
              rhs: {($ Id.VSub_DollarName '$TRASH_DIRECTORY')}
              spids: [5353]
            )
          ]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (C {<rm>} {<-fr>} {(DQ ($ Id.VSub_DollarName '$TRASH_DIRECTORY'))})
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:GIT_EXIT_OK)
                  op: assign_op.Equal
                  rhs: {<t>}
                  spids: [5369]
                )
              ]
            )
            (command.Simple
              words: [{<echo>} {(DQ <'FATAL: Cannot prepare test area'>)}]
              redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<5>})]
              do_fork: T
            )
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:HOME)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$TRASH_DIRECTORY'))}
          spids: [5390]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:GNUPGHOME)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$HOME') <'/gnupg-home-not-used'>)}
          spids: [5395]
        )
      ]
    )
    (C {<export>} {<HOME>} {<GNUPGHOME>})
    (command.If
      arms: [
        (if_arm
          cond: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$TEST_NO_CREATE_REPO'))})]
          action: [(C {<test_create_repo>} {(DQ ($ Id.VSub_DollarName '$TRASH_DIRECTORY'))})]
          spids: [5408 5418]
        )
      ]
      else_action: [(C {<mkdir>} {<-p>} {(DQ ($ Id.VSub_DollarName '$TRASH_DIRECTORY'))})]
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (C {<cd>} {<-P>} {(DQ ($ Id.VSub_DollarName '$TRASH_DIRECTORY'))})
        (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:this_test)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                token: <Id.VSub_Number 0>
                suffix_op: (suffix_op.Unary op_id:Id.VOp1_DPound arg_word:{<'*'> <Id.Lit_Slash '/'>})
              )
            }
          spids: [5461]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:this_test)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                token: <Id.VSub_Name this_test>
                suffix_op: (suffix_op.Unary op_id:Id.VOp1_DPercent arg_word:{<'-*'>})
              )
            }
          spids: [5469]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (C {<match_pattern_list>} {(DQ ($ Id.VSub_DollarName '$this_test'))} 
              {($ Id.VSub_DollarName '$GIT_SKIP_TESTS')}
            )
          ]
          action: [
            (command.Simple
              words: [
                {<say_color>}
                {<info>}
                {(DQ <'skipping test '> ($ Id.VSub_DollarName '$this_test') <' altogether'>)}
              ]
              redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<3>})]
              do_fork: T
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:skip_all)
                  op: assign_op.Equal
                  rhs: {(DQ <'skip all tests in '> ($ Id.VSub_DollarName '$this_test'))}
                  spids: [5503]
                )
              ]
            )
            (C {<test_done>})
          ]
          spids: [5476 5486]
        )
      ]
    )
    (command.ShFunction
      name: yes
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [(C {<test>} {($ Id.VSub_Pound '$#')} {<Id.Lit_Equals '='>} {<0>})]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:y)
                          op: assign_op.Equal
                          rhs: {<y>}
                          spids: [5540]
                        )
                      ]
                    )
                  ]
                  spids: [5526 5537]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:y)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_Star '$*'))}
                      spids: [5547]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:i)
                  op: assign_op.Equal
                  rhs: {<0>}
                  spids: [5557]
                )
              ]
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: [(C {<test>} {($ Id.VSub_DollarName '$i')} {<-lt>} {<99>})]
              body: 
                (command.DoGroup
                  children: [
                    (C {<echo>} {(DQ ($ Id.VSub_DollarName '$y'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:i)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (word_part.ArithSub
                                anode: 
                                  (arith_expr.Binary
                                    op_id: Id.Arith_Plus
                                    left: {($ Id.VSub_DollarName '$i')}
                                    right: {<Id.Lit_Digits 1>}
                                  )
                              )
                            }
                          spids: [5582]
                        )
                      ]
                    )
                  ]
                )
            )
          ]
        )
    )
    (command.Case
      to_match: {(command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<uname>} {<-s>}))}
      arms: [
        (case_arm
          pat_list: [{<Id.Lit_Star '*'> <MINGW> <Id.Lit_Star '*'>}]
          action: [
            (command.ShFunction
              name: sort
              body: (BraceGroup children:[(C {<'/usr/bin/sort'>} {(DQ ($ Id.VSub_At '$@'))})])
            )
            (command.ShFunction
              name: find
              body: (BraceGroup children:[(C {<'/usr/bin/find'>} {(DQ ($ Id.VSub_At '$@'))})])
            )
            (command.ShFunction
              name: sum
              body: (BraceGroup children:[(C {<md5sum>} {(DQ ($ Id.VSub_At '$@'))})])
            )
            (command.ShFunction
              name: pwd
              body: (BraceGroup children:[(C {<builtin>} {<pwd>} {<-W>})])
            )
            (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.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:GIT_TEST_CMP)
                  op: assign_op.Equal
                  rhs: {<mingw_test_cmp>}
                  spids: [5727]
                )
              ]
            )
          ]
          spids: [5609 5612 5731 -1]
        )
        (case_arm
          pat_list: [{<Id.Lit_Star '*'> <CYGWIN> <Id.Lit_Star '*'>}]
          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: [5733 5736 5764 -1]
        )
        (case_arm
          pat_list: [{<Id.Lit_Star '*'>}]
          action: [
            (C {<test_set_prereq>} {<POSIXPERM>})
            (C {<test_set_prereq>} {<BSLASHPSPEC>})
            (C {<test_set_prereq>} {<EXECKEEPSPID>})
          ]
          spids: [5766 5767 5785 -1]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.Subshell
          child: 
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:COLUMNS)
                      op: assign_op.Equal
                      rhs: {<1>}
                      spids: [5792]
                    )
                  ]
                )
                (C {<test>} {($ Id.VSub_DollarName '$COLUMNS')} {<Id.Lit_Equals '='>} {<1>})
              ]
            )
        )
        (C {<test_set_prereq>} {<COLUMNS_CAN_BE_1>})
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$NO_PERL'))})
        (C {<test_set_prereq>} {<PERL>})
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$NO_PYTHON'))})
        (C {<test_set_prereq>} {<PYTHON>})
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$USE_LIBPCRE'))})
        (C {<test_set_prereq>} {<LIBPCRE>})
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$NO_GETTEXT'))})
        (C {<test_set_prereq>} {<GETTEXT>})
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$GETTEXT_POISON'))})]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:GIT_GETTEXT_POISON)
                  op: assign_op.Equal
                  rhs: {<YesPlease>}
                  spids: [5886]
                )
              ]
            )
            (C {<export>} {<GIT_GETTEXT_POISON>})
            (C {<test_set_prereq>} {<GETTEXT_POISON>})
          ]
          spids: [5873 5883]
        )
      ]
      else_action: [(C {<test_set_prereq>} {<C_LOCALE_OUTPUT>})]
    )
    (command.ShFunction
      name: test_i18ncmp
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$GETTEXT_POISON'))})
                (C {<test_cmp>} {(DQ ($ Id.VSub_At '$@'))})
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: test_i18ngrep
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$GETTEXT_POISON'))})]
                  action: [(C {<Id.Lit_Colon ':'>})]
                  spids: [5971 5982]
                )
                (if_arm
                  cond: [
                    (C {<test>} {(DQ <'x!'>)} {<Id.Lit_Equals '='>} {(DQ <x> ($ Id.VSub_Number '$1'))})
                  ]
                  action: [
                    (C {<shift>})
                    (command.Pipeline
                      children: [(C {<grep>} {(DQ ($ Id.VSub_At '$@'))})]
                      negated: T
                    )
                  ]
                  spids: [5991 6007]
                )
              ]
              else_action: [(C {<grep>} {(DQ ($ Id.VSub_At '$@'))})]
            )
          ]
        )
    )
    (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.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:GIT_UNZIP)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                token: <Id.VSub_Name GIT_UNZIP>
                suffix_op: (suffix_op.Unary op_id:Id.VTest_ColonHyphen arg_word:{<unzip>})
              )
            }
          spids: [6217]
        )
      ]
    )
    (C {<test_lazy_prereq>} {<UNZIP>} {(SQ <'\n'> <'\t"$GIT_UNZIP" -v\n'> <'\ttest $? -ne 127\n'>)})
    (command.ShFunction
      name: run_with_limited_cmdline
      body: 
        (BraceGroup
          children: [
            (command.Subshell
              child: 
                (command.AndOr
                  ops: [Id.Op_DAmp]
                  children: [(C {<ulimit>} {<-s>} {<128>}) (C {(DQ ($ Id.VSub_At '$@'))})]
                )
            )
          ]
        )
    )
    (C {<test_lazy_prereq>} {<CMDLINE_LIMIT>} {(SQ <'run_with_limited_cmdline true'>)})
    (command.ShFunction
      name: build_option
      body: 
        (BraceGroup
          children: [
            (command.Pipeline
              children: [
                (C {<git>} {<version>} {<--build-options>})
                (C {<sed>} {<-ne>} {(DQ <'s/^'> ($ Id.VSub_Number '$1') <': //p'>)})
              ]
              negated: F
            )
          ]
        )
    )
    (C {<test_lazy_prereq>} {<LONG_IS_64BIT>} 
      {(SQ <'\n'> <'\ttest 8 -le "$(build_option sizeof-long)"\n'>)}
    )
  ]
)