(CommandList
  children: [
    (C {(set)} {(-e)})
    (C {(set)} {(-o)} {(pipefail)})
    (C {(Lit_Other ":")} 
      {
        (BracedVarSub
          token: <VSub_Name outputs>
          suffix_op: (StringUnary op_id:VTest_ColonEquals arg_word:{(out)})
          spids: [13 17]
        )
      }
    )
    (FuncDef
      name: runHook
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:hookName)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [50]
                )
              ]
              spids: [48]
            )
            (C {(shift)})
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:var)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$hookName"))}
                  spids: [61]
                )
              ]
              spids: [59]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_EqualTilde
                              left: {(DQ ($ VSub_Name "$hookName"))}
                              right: {(Hook) (Lit_Other "$")}
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:var)
                              op: PlusEqual
                              rhs: {(s)}
                              spids: [85]
                            )
                          ]
                          spids: [85]
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  spids: [-1 83]
                )
              ]
              else_action: [
                (Sentence
                  child: 
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:var)
                          op: PlusEqual
                          rhs: {(Hooks)}
                          spids: [91]
                        )
                      ]
                      spids: [91]
                    )
                  terminator: <Op_Semi ";">
                )
              ]
              spids: [89 95]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:varRef)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$var") ("[@]"))}
                  spids: [101]
                )
              ]
              spids: [99]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [(assign_pair lhs:(LhsName name:hook) op:Equal spids:[110])]
              spids: [108]
            )
            (ForEach
              iter_name: hook
              iter_words: [
                {(DQ ("_callImplicitHook 0 ") ($ VSub_Name "$hookName"))}
                {(DQ (BracedVarSub token:<VSub_Name varRef> prefix_op:VSub_Bang spids:[125128]))}
              ]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [(C {(_eval)} {(DQ ($ VSub_Name "$hook"))} {(DQ ($ VSub_At "$@"))})]
                  spids: [132 146]
                )
              spids: [118 130]
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
          ]
          spids: [45]
        )
      spids: [41 44]
    )
    (FuncDef
      name: runOneHook
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:hookName)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [172]
                )
              ]
              spids: [170]
            )
            (C {(shift)})
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:var)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$hookName"))}
                  spids: [183]
                )
              ]
              spids: [181]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_EqualTilde
                              left: {(DQ ($ VSub_Name "$hookName"))}
                              right: {(Hook) (Lit_Other "$")}
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:var)
                              op: PlusEqual
                              rhs: {(s)}
                              spids: [207]
                            )
                          ]
                          spids: [207]
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  spids: [-1 205]
                )
              ]
              else_action: [
                (Sentence
                  child: 
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:var)
                          op: PlusEqual
                          rhs: {(Hooks)}
                          spids: [213]
                        )
                      ]
                      spids: [213]
                    )
                  terminator: <Op_Semi ";">
                )
              ]
              spids: [211 217]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:varRef)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$var") ("[@]"))}
                  spids: [223]
                )
              ]
              spids: [221]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [(assign_pair lhs:(LhsName name:hook) op:Equal spids:[232])]
              spids: [230]
            )
            (ForEach
              iter_name: hook
              iter_words: [
                {(DQ ("_callImplicitHook 1 ") ($ VSub_Name "$hookName"))}
                {(DQ (BracedVarSub token:<VSub_Name varRef> prefix_op:VSub_Bang spids:[247250]))}
              ]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(_eval)} {(DQ ($ VSub_Name "$hook"))} {(DQ ($ VSub_At "$@"))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                          spids: [-1 270]
                        )
                      ]
                      spids: [-1 278]
                    )
                  ]
                  spids: [254 281]
                )
              spids: [240 252]
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
          spids: [167]
        )
      spids: [163 166]
    )
    (FuncDef
      name: _callImplicitHook
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:def)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [316]
                )
              ]
              spids: [314]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:hookName)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$2"))}
                  spids: [324]
                )
              ]
              spids: [322]
            )
            (Case
              to_match: 
                {
                  (DQ 
                    (CommandSubPart
                      command_list: 
                        (CommandList
                          children: [
                            (AndOr
                              children: [
                                (C {(type)} {(-t)} {(DQ ($ VSub_Name "$hookName"))})
                                (C {(true)})
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                        )
                      left_token: <Left_CommandSub "$(">
                      spids: [333 345]
                    )
                  )
                }
              arms: [
                (case_arm
                  pat_list: [{(KW_Function function)} {(alias)} {(builtin)}]
                  action: [(C {(DQ ($ VSub_Name "$hookName"))})]
                  spids: [351 357 362 -1]
                )
                (case_arm
                  pat_list: [{(file)}]
                  action: [(C {(source)} {(DQ ($ VSub_Name "$hookName"))})]
                  spids: [365 367 374 -1]
                )
                (case_arm
                  pat_list: [{(keyword)}]
                  action: [(C {(Lit_Other ":")})]
                  spids: [377 379 382 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-z)} 
                                  {
                                    (DQ 
                                      (BracedVarSub
                                        token: <VSub_Name hookName>
                                        prefix_op: VSub_Bang
                                        spids: [396 399]
                                      )
                                    )
                                  } {(Lit_Other "]")}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Sentence
                              child: 
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {(DQ ($ VSub_Name "$def"))}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          spids: [-1 405]
                        )
                      ]
                      else_action: [
                        (Sentence
                          child: 
                            (C {(eval)} 
                              {
                                (DQ 
                                  (BracedVarSub
                                    token: <VSub_Name hookName>
                                    prefix_op: VSub_Bang
                                    spids: [419 422]
                                  )
                                )
                              }
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      spids: [414 426]
                    )
                  ]
                  spids: [385 387 427 -1]
                )
              ]
              spids: [330 348 430]
            )
          ]
          spids: [311]
        )
      spids: [307 310]
    )
    (FuncDef
      name: _eval
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:code)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [451]
                )
              ]
              spids: [449]
            )
            (C {(shift)})
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [(C {(type)} {(-t)} {(DQ ($ VSub_Name "$code"))})]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [465 473]
                              )
                            )
                          } {(Lit_Other "=")} {(KW_Function function)} {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(eval)} 
                      {
                        (DQ ($ VSub_Name "$code") (" ") 
                          (EscapedLiteralPart
                            token: <Lit_EscapedChar "\\\"">
                          ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("@") 
                          (EscapedLiteralPart
                            token: <Lit_EscapedChar "\\\"">
                          )
                        )
                      }
                    )
                  ]
                  spids: [-1 483]
                )
              ]
              else_action: [(C {(eval)} {(DQ ($ VSub_Name "$code"))})]
              spids: [498 508]
            )
          ]
          spids: [446]
        )
      spids: [442 445]
    )
    (FuncDef
      name: stopNest
      body: 
        (BraceGroup
          children: [(Sentence child:(C {(true)}) terminator:<Op_Semi ";">)]
          spids: [528]
        )
      spids: [524 527]
    )
    (FuncDef
      name: header
      body: 
        (BraceGroup
          children: [
            (Sentence
              child: (C {(echo)} {(DQ ($ VSub_Number "$1"))})
              terminator: <Op_Semi ";">
            )
          ]
          spids: [539]
        )
      spids: [535 538]
    )
    (FuncDef
      name: closeNest
      body: 
        (BraceGroup
          children: [(Sentence child:(C {(true)}) terminator:<Op_Semi ";">)]
          spids: [554]
        )
      spids: [550 553]
    )
    (FuncDef
      name: echoCmd
      body: 
        (BraceGroup
          children: [
            (C {(printf)} {(DQ ("%s:"))} {(DQ ($ VSub_Number "$1"))})
            (C {(shift)})
            (C {(printf)} {(SQ <" %q">)} {(DQ ($ VSub_At "$@"))})
            (C {(echo)})
          ]
          spids: [578]
        )
      spids: [574 577]
    )
    (FuncDef
      name: exitHandler
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:exitCode)
                  op: Equal
                  rhs: {(DQ ($ VSub_QMark "$?"))}
                  spids: [626]
                )
              ]
              spids: [626]
            )
            (C {(set)} {(Lit_Other "+") (e)})
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-n)} {(DQ ($ VSub_Name "$showBuildStats"))} 
                          {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (SimpleCommand
                      words: [{(times)}]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: {(DQ ($ VSub_Name "$NIX_BUILD_TOP") (/.times))}
                          spids: [657]
                        )
                      ]
                    )
                    (Assignment
                      keyword: Assign_Local
                      flags: ["'-a'"]
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:times)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(cat)} {(DQ ($ VSub_Name "$NIX_BUILD_TOP") (/.times))})
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [671 678]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [669]
                        )
                      ]
                      spids: [665]
                    )
                    (C {(echo)} {(DQ ("build time elapsed: "))} 
                      {
                        (DQ 
                          (BracedVarSub
                            token: <VSub_Name times>
                            bracket_op: (WholeArray op_id:Lit_At)
                            spids: [709 714]
                          )
                        )
                      }
                    )
                  ]
                  spids: [-1 652]
                )
              ]
              spids: [-1 718]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$exitCode"))} 
                          {(KW_Bang "!") (Lit_Other "=")} {(0)} {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(runHook)} {(failureHook)})
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-n)} {(DQ ($ VSub_Name "$succeedOnFailure"))} 
                                  {(Lit_Other "]")}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(echo)} 
                              {
                                (DQ ("build failed with exit code ") ($ VSub_Name "$exitCode") 
                                  (" (ignored)")
                                )
                              }
                            )
                            (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$out") (/nix-support))})
                            (SimpleCommand
                              words: [{(printf)} {(DQ ("%s"))} {(DQ ($ VSub_Name "$exitCode"))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_Great
                                  fd: -1
                                  arg_word: {(DQ ($ VSub_Name "$out") (/nix-support/failed))}
                                  spids: [808]
                                )
                              ]
                            )
                            (C {(exit)} {(0)})
                          ]
                          spids: [-1 776]
                        )
                      ]
                      spids: [-1 821]
                    )
                  ]
                  spids: [-1 738]
                )
              ]
              else_action: [(C {(runHook)} {(exitHook)})]
              spids: [825 833]
            )
            (C {(exit)} {(DQ ($ VSub_Name "$exitCode"))})
          ]
          spids: [623]
        )
      spids: [619 622]
    )
    (C {(trap)} {(DQ (exitHandler))} {(EXIT)})
    (FuncDef
      name: addToSearchPathWithCustomDelimiter
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:delimiter)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [873]
                )
              ]
              spids: [871]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:varName)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$2"))}
                  spids: [881]
                )
              ]
              spids: [879]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:dir)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$3"))}
                  spids: [889]
                )
              ]
              spids: [887]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (C {(Lit_Other "[")} {(-d)} {(DQ ($ VSub_Name "$dir"))} {(Lit_Other "]")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(export)} 
                      {
                        (DQ (${ VSub_Name varName) ("=") 
                          (BracedVarSub
                            token: <VSub_Name varName>
                            prefix_op: VSub_Bang
                            spids: [918 921]
                          ) 
                          (BracedVarSub
                            token: <VSub_Name varName>
                            prefix_op: VSub_Bang
                            suffix_op: 
                              (StringUnary
                                op_id: VTest_ColonPlus
                                arg_word: {($ VSub_Name "$delimiter")}
                              )
                            spids: [922 927]
                          ) (${ VSub_Name dir)
                        )
                      }
                    )
                  ]
                  spids: [-1 908]
                )
              ]
              spids: [-1 934]
            )
          ]
          spids: [868]
        )
      spids: [864 867]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:PATH_DELIMITER) op:Equal rhs:{(SQ <":">)} spids:[939])]
      spids: [939]
    )
    (FuncDef
      name: addToSearchPath
      body: 
        (BraceGroup
          children: [
            (C {(addToSearchPathWithCustomDelimiter)} {(DQ (${ VSub_Name PATH_DELIMITER))} 
              {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [949]
        )
      spids: [945 948]
    )
    (FuncDef
      name: ensureDir
      body: 
        (BraceGroup
          children: [
            (SimpleCommand
              words: [
                {(echo)}
                {
                  (DQ ("warning: \u2018ensureDir\u2019 is deprecated; use \u2018mkdir\u2019 instead"))
                }
              ]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[981])]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [(assign_pair lhs:(LhsName name:dir) op:Equal spids:[987])]
              spids: [985]
            )
            (ForEach
              iter_name: dir
              iter_words: [{(DQ ($ VSub_At "$@"))}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (Pipeline
                                  children: [
                                    (C {(Lit_Other "[")} {(-x)} {(DQ ($ VSub_Name "$dir"))} 
                                      {(Lit_Other "]")}
                                    )
                                  ]
                                  negated: True
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Sentence
                              child: (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$dir"))})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          spids: [-1 1019]
                        )
                      ]
                      spids: [-1 1030]
                    )
                  ]
                  spids: [1001 1033]
                )
              spids: [995 999]
            )
          ]
          spids: [972]
        )
      spids: [968 971]
    )
    (FuncDef
      name: _addRpathPrefix
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$NIX_NO_SELF_RPATH"))} 
                          {(KW_Bang "!") (Lit_Other "=")} {(1)} {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(export)} 
                      {(Lit_VarLike "NIX_LDFLAGS=") 
                        (DQ ("-rpath ") ($ VSub_Number "$1") ("/lib ") ($ VSub_Name "$NIX_LDFLAGS"))
                      }
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-n)} 
                                  {(DQ ($ VSub_Name "$NIX_LIB64_IN_SELF_RPATH"))} {(Lit_Other "]")}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(export)} 
                              {(Lit_VarLike "NIX_LDFLAGS=") 
                                (DQ ("-rpath ") ($ VSub_Number "$1") ("/lib64 ") 
                                  ($ VSub_Name "$NIX_LDFLAGS")
                                )
                              }
                            )
                          ]
                          spids: [-1 1098]
                        )
                      ]
                      spids: [-1 1112]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-n)} 
                                  {(DQ ($ VSub_Name "$NIX_LIB32_IN_SELF_RPATH"))} {(Lit_Other "]")}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(export)} 
                              {(Lit_VarLike "NIX_LDFLAGS=") 
                                (DQ ("-rpath ") ($ VSub_Number "$1") ("/lib32 ") 
                                  ($ VSub_Name "$NIX_LDFLAGS")
                                )
                              }
                            )
                          ]
                          spids: [-1 1128]
                        )
                      ]
                      spids: [-1 1142]
                    )
                  ]
                  spids: [-1 1071]
                )
              ]
              spids: [-1 1145]
            )
          ]
          spids: [1052]
        )
      spids: [1048 1051]
    )
    (FuncDef
      name: isELF
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:fn)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [1162]
                )
              ]
              spids: [1160]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [(assign_pair lhs:(LhsName name:fd) op:Equal spids:[1170])]
              spids: [1168]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [(assign_pair lhs:(LhsName name:magic) op:Equal spids:[1175])]
              spids: [1173]
            )
            (SimpleCommand
              words: [{(exec)} {(Lit_LBrace "{") (fd) (Lit_RBrace "}")}]
              redirects: [
                (Redir
                  op_id: Redir_Less
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$fn"))}
                  spids: [1183]
                )
              ]
            )
            (C {(read)} {(-r)} {(-n)} {(4)} {(-u)} {(DQ ($ VSub_Name "$fd"))} {(magic)})
            (SimpleCommand
              words: [{(exec)} {(Lit_LBrace "{") (fd) (Lit_RBrace "}")}]
              redirects: [(Redir op_id:Redir_LessAnd fd:-1 arg_word:{(-)} spids:[1212])]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_EqualTilde
                              left: {(DQ ($ VSub_Name "$magic"))}
                              right: {(ELF)}
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Sentence
                      child: (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  spids: [-1 1231]
                )
              ]
              else_action: [
                (Sentence
                  child: (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
                  terminator: <Op_Semi ";">
                )
              ]
              spids: [1238 1245]
            )
          ]
          spids: [1157]
        )
      spids: [1153 1156]
    )
    (FuncDef
      name: isScript
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:fn)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [1265]
                )
              ]
              spids: [1263]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [(assign_pair lhs:(LhsName name:fd) op:Equal spids:[1273])]
              spids: [1271]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [(assign_pair lhs:(LhsName name:magic) op:Equal spids:[1278])]
              spids: [1276]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (Pipeline
                          children: [(C {(Lit_Other "[")} {(-x)} {(/bin/sh)} {(Lit_Other "]")})]
                          negated: True
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Sentence
                      child: (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  spids: [-1 1294]
                )
              ]
              spids: [-1 1301]
            )
            (SimpleCommand
              words: [{(exec)} {(Lit_LBrace "{") (fd) (Lit_RBrace "}")}]
              redirects: [
                (Redir
                  op_id: Redir_Less
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$fn"))}
                  spids: [1309]
                )
              ]
            )
            (C {(read)} {(-r)} {(-n)} {(2)} {(-u)} {(DQ ($ VSub_Name "$fd"))} {(magic)})
            (SimpleCommand
              words: [{(exec)} {(Lit_LBrace "{") (fd) (Lit_RBrace "}")}]
              redirects: [(Redir op_id:Redir_LessAnd fd:-1 arg_word:{(-)} spids:[1338])]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_EqualTilde
                              left: {(DQ ($ VSub_Name "$magic"))}
                              right: 
                                {(EscapedLiteralPart token:<Lit_EscapedChar "\\#">) (Lit_Other "!")}
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Sentence
                      child: (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  spids: [-1 1358]
                )
              ]
              else_action: [
                (Sentence
                  child: (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
                  terminator: <Op_Semi ";">
                )
              ]
              spids: [1365 1372]
            )
          ]
          spids: [1260]
        )
      spids: [1256 1259]
    )
    (FuncDef
      name: printLines
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (DBracket
                  expr: (BoolBinary op_id:BoolBinary_gt left:{(DQ ($ VSub_Pound "$#"))} right:{(0)})
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
              ]
              op_id: Op_DPipe
            )
            (C {(printf)} {(SQ <"%s\\n">)} {(DQ ($ VSub_At "$@"))})
          ]
          spids: [1384]
        )
      spids: [1380 1383]
    )
    (FuncDef
      name: printWords
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (DBracket
                  expr: (BoolBinary op_id:BoolBinary_gt left:{(DQ ($ VSub_Pound "$#"))} right:{(0)})
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
              ]
              op_id: Op_DPipe
            )
            (C {(printf)} {(SQ <"%s ">)} {(DQ ($ VSub_At "$@"))})
          ]
          spids: [1423]
        )
      spids: [1419 1422]
    )
    (C {(export)} {(SOURCE_DATE_EPOCH)})
    (C {(Lit_Other ":")} 
      {
        (BracedVarSub
          token: <VSub_Name SOURCE_DATE_EPOCH>
          suffix_op: (StringUnary op_id:VTest_ColonEquals arg_word:{(1)})
          spids: [1484 1488]
        )
      }
    )
    (C {(shopt)} {(-s)} {(nullglob)})
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:PATH) op:Equal rhs:{(SQ )} spids:[1512])]
      spids: [1512]
    )
    (ForEach
      iter_name: i
      iter_words: [{($ VSub_Name "$initialPath")}]
      do_arg_iter: False
      body: 
        (DoGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$i"))} {(Lit_Other "=")} {(/)} 
                          {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:i)
                              op: Equal
                              rhs: {(SQ )}
                              spids: [1543]
                            )
                          ]
                          spids: [1543]
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  spids: [-1 1541]
                )
              ]
              spids: [-1 1546]
            )
            (C {(addToSearchPath)} {(PATH)} {(DQ ($ VSub_Name "$i") (/bin))})
          ]
          spids: [1523 1558]
        )
      spids: [1519 1521]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$NIX_DEBUG"))} {(Lit_Other "=")} {(1)} 
                  {(Lit_Other "]")}
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [(C {(echo)} {(DQ ("initial path: ") ($ VSub_Name "$PATH"))})]
          spids: [-1 1576]
        )
      ]
      spids: [-1 1586]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$SHELL"))} {(Lit_Other "]")})
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (Sentence
              child: (C {(echo)} {(DQ ("SHELL not set"))})
              terminator: <Op_Semi ";">
            )
            (Sentence child:(C {(exit)} {(1)}) terminator:<Op_Semi ";">)
          ]
          spids: [-1 1606]
        )
      ]
      spids: [-1 1620]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:BASH)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$SHELL"))}
          spids: [1622]
        )
      ]
      spids: [1622]
    )
    (C {(export)} {(Lit_VarLike "CONFIG_SHELL=") (DQ ($ VSub_Name "$SHELL"))})
    (FuncDef
      name: paxmark
      body: 
        (BraceGroup
          children: [(Sentence child:(C {(true)}) terminator:<Op_Semi ";">)]
          spids: [1646]
        )
      spids: [1642 1645]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$shell"))} {(Lit_Other "]")})
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (Sentence
              child: (C {(export)} {(Lit_VarLike "shell=") (DQ ($ VSub_Name "$SHELL"))})
              terminator: <Op_Semi ";">
            )
          ]
          spids: [-1 1671]
        )
      ]
      spids: [-1 1681]
    )
    (C {(runHook)} {(preHook)})
    (C {(runHook)} {(addInputsHook)})
    (FuncDef
      name: findInputs
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkg)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [1716]
                )
              ]
              spids: [1714]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:var)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$2"))}
                  spids: [1724]
                )
              ]
              spids: [1722]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:propagatedBuildInputsFile)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$3"))}
                  spids: [1732]
                )
              ]
              spids: [1730]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:varRef)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$var") ("[*]"))}
                  spids: [1757]
                )
              ]
              spids: [1755]
            )
            (Case
              to_match: 
                {(DQ (BracedVarSub token:<VSub_Name varRef> prefix_op:VSub_Bang spids:[17681771]))}
              arms: [
                (case_arm
                  pat_list: [{(Lit_Other "*") (DQ (" ") ($ VSub_Name "$pkg") (" ")) (Lit_Other "*")}]
                  action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                  spids: [1777 1784 1790 -1]
                )
              ]
              spids: [1765 1774 1793]
            )
            (C {(eval)} {(DQ ($ VSub_Name "$var")) (SQ <"+=(\"$pkg\")">)})
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (Pipeline
                          children: [
                            (C {(Lit_Other "[")} {(-e)} {(DQ ($ VSub_Name "$pkg"))} {(Lit_Other "]")})
                          ]
                          negated: True
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (SimpleCommand
                      words: [{(echo)} {(DQ ("build input ") ($ VSub_Name "$pkg") (" does not exist"))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[1834])]
                    )
                    (C {(exit)} {(1)})
                  ]
                  spids: [-1 1823]
                )
              ]
              spids: [-1 1843]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (C {(Lit_Other "[")} {(-f)} {(DQ ($ VSub_Name "$pkg"))} {(Lit_Other "]")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [(C {(source)} {(DQ ($ VSub_Name "$pkg"))})]
                  spids: [-1 1860]
                )
              ]
              spids: [-1 1870]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-d)} {(DQ ($ VSub_Name "$pkg") (/bin))} {(Lit_Other "]")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [(C {(addToSearchPath)} {(_PATH)} {(DQ ($ VSub_Name "$pkg") (/bin))})]
                  spids: [-1 1888]
                )
              ]
              spids: [-1 1901]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-f)} {(DQ ($ VSub_Name "$pkg") (/nix-support/setup-hook))} 
                          {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [(C {(source)} {(DQ ($ VSub_Name "$pkg") (/nix-support/setup-hook))})]
                  spids: [-1 1919]
                )
              ]
              spids: [-1 1930]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-f)} 
                          {
                            (DQ ($ VSub_Name "$pkg") (/nix-support/) 
                              ($ VSub_Name "$propagatedBuildInputsFile")
                            )
                          } {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_Local
                      pairs: [(assign_pair lhs:(LhsName name:pkgNext) op:Equal spids:[1954])]
                      spids: [1952]
                    )
                    (ForEach
                      iter_name: pkgNext
                      iter_words: [
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (SimpleCommand
                                    redirects: [
                                      (Redir
                                        op_id: Redir_Less
                                        fd: -1
                                        arg_word: 
                                          {
                                            (DQ ($ VSub_Name "$pkg") (/nix-support/) 
                                              ($ VSub_Name "$propagatedBuildInputsFile")
                                            )
                                          }
                                        spids: [1964]
                                      )
                                    ]
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [1963 1971]
                          )
                        }
                      ]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (C {(findInputs)} {(DQ ($ VSub_Name "$pkgNext"))} {(DQ ($ VSub_Name "$var"))} 
                              {(DQ ($ VSub_Name "$propagatedBuildInputsFile"))}
                            )
                          ]
                          spids: [1974 1992]
                        )
                      spids: [1962 1972]
                    )
                  ]
                  spids: [-1 1949]
                )
              ]
              spids: [-1 1995]
            )
          ]
          spids: [1711]
        )
      spids: [1707 1710]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$crossConfig"))} {(Lit_Other "]")})
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (Assignment
              keyword: Assign_Declare
              flags: ["'-a'"]
              pairs: [(assign_pair lhs:(LhsName name:nativePkgs) op:Equal spids:[2028])]
              spids: [2024]
            )
            (ForEach
              iter_name: i
              iter_words: [
                {($ VSub_Name "$nativeBuildInputs")}
                {($ VSub_Name "$buildInputs")}
                {($ VSub_Name "$defaultNativeBuildInputs")}
                {($ VSub_Name "$defaultBuildInputs")}
                {($ VSub_Name "$propagatedNativeBuildInputs")}
                {($ VSub_Name "$propagatedBuildInputs")}
              ]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (C {(findInputs)} {(DQ ($ VSub_Name "$i"))} {(nativePkgs)} 
                      {(propagated-native-build-inputs)}
                    )
                  ]
                  spids: [2054 2068]
                )
              spids: [2036 2052]
            )
          ]
          spids: [-1 2013]
        )
      ]
      else_action: [
        (Assignment
          keyword: Assign_Declare
          flags: ["'-a'"]
          pairs: [(assign_pair lhs:(LhsName name:crossPkgs) op:Equal spids:[2077])]
          spids: [2073]
        )
        (ForEach
          iter_name: i
          iter_words: [
            {($ VSub_Name "$buildInputs")}
            {($ VSub_Name "$defaultBuildInputs")}
            {($ VSub_Name "$propagatedBuildInputs")}
          ]
          do_arg_iter: False
          body: 
            (DoGroup
              children: [
                (C {(findInputs)} {(DQ ($ VSub_Name "$i"))} {(crossPkgs)} {(propagated-build-inputs)})
              ]
              spids: [2093 2107]
            )
          spids: [2085 2091]
        )
        (Assignment
          keyword: Assign_Declare
          flags: ["'-a'"]
          pairs: [(assign_pair lhs:(LhsName name:nativePkgs) op:Equal spids:[2115])]
          spids: [2111]
        )
        (ForEach
          iter_name: i
          iter_words: [
            {($ VSub_Name "$nativeBuildInputs")}
            {($ VSub_Name "$defaultNativeBuildInputs")}
            {($ VSub_Name "$propagatedNativeBuildInputs")}
          ]
          do_arg_iter: False
          body: 
            (DoGroup
              children: [
                (C {(findInputs)} {(DQ ($ VSub_Name "$i"))} {(nativePkgs)} 
                  {(propagated-native-build-inputs)}
                )
              ]
              spids: [2131 2145]
            )
          spids: [2123 2129]
        )
      ]
      spids: [2070 2147]
    )
    (FuncDef
      name: _addToNativeEnv
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkg)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [2166]
                )
              ]
              spids: [2164]
            )
            (C {(runHook)} {(envHook)} {(DQ ($ VSub_Name "$pkg"))})
          ]
          spids: [2161]
        )
      spids: [2157 2160]
    )
    (ForEach
      iter_name: i
      iter_words: [
        {
          (DQ 
            (BracedVarSub
              token: <VSub_Name nativePkgs>
              bracket_op: (WholeArray op_id:Lit_At)
              spids: [2195 2200]
            )
          )
        }
      ]
      do_arg_iter: False
      body: (DoGroup children:[(C {(_addToNativeEnv)} {(DQ ($ VSub_Name "$i"))})] spids:[22042213])
      spids: [2193 2202]
    )
    (FuncDef
      name: _addToCrossEnv
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkg)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [2225]
                )
              ]
              spids: [2223]
            )
            (C {(runHook)} {(crossEnvHook)} {(DQ ($ VSub_Name "$pkg"))})
          ]
          spids: [2220]
        )
      spids: [2216 2219]
    )
    (ForEach
      iter_name: i
      iter_words: [
        {
          (DQ 
            (BracedVarSub
              token: <VSub_Name crossPkgs>
              bracket_op: (WholeArray op_id:Lit_At)
              spids: [2254 2259]
            )
          )
        }
      ]
      do_arg_iter: False
      body: (DoGroup children:[(C {(_addToCrossEnv)} {(DQ ($ VSub_Name "$i"))})] spids:[22632272])
      spids: [2252 2261]
    )
    (C {(_addRpathPrefix)} {(DQ ($ VSub_Name "$out"))})
    (C {(export)} {(Lit_VarLike "TZ=") (UTC)})
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$prefix"))} {(Lit_Other "]")})
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (Sentence
              child: 
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:prefix)
                      op: Equal
                      rhs: {(DQ ($ VSub_Name "$out"))}
                      spids: [2325]
                    )
                  ]
                  spids: [2325]
                )
              terminator: <Op_Semi ";">
            )
          ]
          spids: [-1 2322]
        )
      ]
      spids: [-1 2331]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$useTempPrefix"))} {(Lit_Other "=")} {(1)} 
                  {(Lit_Other "]")}
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (Sentence
              child: 
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:prefix)
                      op: Equal
                      rhs: {(DQ ($ VSub_Name "$NIX_BUILD_TOP") (/tmp_prefix))}
                      spids: [2352]
                    )
                  ]
                  spids: [2352]
                )
              terminator: <Op_Semi ";">
            )
          ]
          spids: [-1 2349]
        )
      ]
      spids: [-1 2359]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:PATH)
          op: Equal
          rhs: 
            {($ VSub_Name "$_PATH") 
              (BracedVarSub
                token: <VSub_Name _PATH>
                suffix_op: (StringUnary op_id:VTest_ColonPlus arg_word:{(":")})
                spids: [2365 2369]
              ) ($ VSub_Name "$PATH")
            }
          spids: [2363]
        )
      ]
      spids: [2363]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$NIX_DEBUG"))} {(Lit_Other "=")} {(1)} 
                  {(Lit_Other "]")}
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [(C {(echo)} {(DQ ("final path: ") ($ VSub_Name "$PATH"))})]
          spids: [-1 2387]
        )
      ]
      spids: [-1 2397]
    )
    (C {(export)} {(Lit_VarLike "NIX_INDENT_MAKE=") (1)})
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (C {(Lit_Other "[")} {(-z)} 
                  {
                    (DQ 
                      (BracedVarSub
                        token: <VSub_Name NIX_BUILD_CORES>
                        suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(SQ )})
                        spids: [2428 2431]
                      )
                    )
                  } {(Lit_Other "]")}
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:NIX_BUILD_CORES)
                  op: Equal
                  rhs: {(DQ (1))}
                  spids: [2440]
                )
              ]
              spids: [2440]
            )
          ]
          spids: [-1 2437]
        )
        (if_arm
          cond: [
            (Sentence
              child: 
                (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$NIX_BUILD_CORES"))} {(-le)} {(0)} 
                  {(Lit_Other "]")}
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:NIX_BUILD_CORES)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (AndOr
                                children: [
                                  (SimpleCommand
                                    words: [{(nproc)}]
                                    redirects: [
                                      (Redir
                                        op_id: Redir_Great
                                        fd: 2
                                        arg_word: {(/dev/null)}
                                        spids: [2467]
                                      )
                                    ]
                                  )
                                  (C {(true)})
                                ]
                                op_id: Op_DPipe
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [2464 2473]
                      )
                    }
                  spids: [2463]
                )
              ]
              spids: [2463]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (SimpleCommand
                          words: [
                            {(expr)}
                            {(DQ ($ VSub_Name "$NIX_BUILD_CORES"))}
                            {(Lit_Other ":")}
                            {(DQ ("^[0-9][0-9]*") (Lit_Other "$"))}
                          ]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: -1
                              arg_word: {(/dev/null)}
                              spids: [2480]
                            )
                            (Redir
                              op_id: Redir_GreatAnd
                              fd: 2
                              arg_word: {(1)}
                              spids: [2483]
                            )
                          ]
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [(C {(Lit_Other ":")})]
                  spids: [-1 2498]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:NIX_BUILD_CORES)
                      op: Equal
                      rhs: {(DQ (1))}
                      spids: [2507]
                    )
                  ]
                  spids: [2507]
                )
              ]
              spids: [2504 2513]
            )
          ]
          spids: [2445 2460]
        )
      ]
      spids: [-1 2515]
    )
    (C {(export)} {(NIX_BUILD_CORES)})
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (AndOr
                  children: [
                    (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$SSL_CERT_FILE"))} {(Lit_Other "]")})
                    (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$IN_NIX_SHELL"))} {(Lit_Other "]")})
                  ]
                  op_id: Op_DAmp
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [(C {(export)} {(Lit_VarLike "SSL_CERT_FILE=") (/no-cert-file.crt)})]
          spids: [-1 2557]
        )
      ]
      spids: [-1 2565]
    )
    (FuncDef
      name: substitute
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:input)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [2586]
                )
              ]
              spids: [2584]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:output)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$2"))}
                  spids: [2594]
                )
              ]
              spids: [2592]
            )
            (C {(shift)} {(2)})
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(KW_Bang "!")} {(-f)} {(DQ ($ VSub_Name "$input"))} 
                          {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (SimpleCommand
                      words: [
                        {(echo)}
                        {
                          (DQ 
                            (BracedVarSub
                              token: <VSub_Name FUNCNAME>
                              bracket_op: (ArrayIndex expr:(ArithWord w:{(Lit_Digits 0)}))
                              spids: [2627 2632]
                            ) ("(): ERROR: file '") ($ VSub_Name "$input") ("' does not exist")
                          )
                        }
                      ]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[2638])]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
                  ]
                  spids: [-1 2621]
                )
              ]
              spids: [-1 2647]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [(assign_pair lhs:(LhsName name:content) op:Equal spids:[2653])]
              spids: [2651]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (SimpleCommand
                          words: [{(read)} {(-r)} {(-N)} {(0)} {(content)}]
                          redirects: [
                            (Redir
                              op_id: Redir_Less
                              fd: -1
                              arg_word: {(DQ ($ VSub_Name "$input"))}
                              spids: [2676]
                            )
                          ]
                          more_env: [(env_pair name:IFS val:{(SQ )} spids:[2662])]
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (SimpleCommand
                      words: [
                        {(echo)}
                        {
                          (DQ 
                            (BracedVarSub
                              token: <VSub_Name FUNCNAME>
                              bracket_op: (ArrayIndex expr:(ArithWord w:{(Lit_Digits 0)}))
                              spids: [2689 2694]
                            ) ("(): ERROR: File ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ($ VSub_Name "$input") 
                            (EscapedLiteralPart
                              token: <Lit_EscapedChar "\\\"">
                            ) (" has null bytes, won't process")
                          )
                        }
                      ]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[2702])]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
                  ]
                  spids: [-1 2683]
                )
              ]
              spids: [-1 2711]
            )
            (While
              cond: [
                (Sentence
                  child: (DParen child:(ArithWord w:{(DQ ($ VSub_Pound "$#"))}))
                  terminator: <Op_Semi ";">
                )
              ]
              body: 
                (DoGroup
                  children: [
                    (Case
                      to_match: {(DQ ($ VSub_Number "$1"))}
                      arms: [
                        (case_arm
                          pat_list: [{(--replace)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:pattern)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number "$2"))}
                                  spids: [2743]
                                )
                              ]
                              spids: [2743]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:replacement)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number "$3"))}
                                  spids: [2749]
                                )
                              ]
                              spids: [2749]
                            )
                            (C {(shift)} {(3)})
                          ]
                          spids: [2739 2740 2760 -1]
                        )
                        (case_arm
                          pat_list: [{(--subst-var)}]
                          action: [
                            (Assignment
                              keyword: Assign_Local
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:varName)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number "$2"))}
                                  spids: [2770]
                                )
                              ]
                              spids: [2768]
                            )
                            (C {(shift)} {(2)})
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (Pipeline
                                          children: [
                                            (DBracket
                                              expr: 
                                                (BoolBinary
                                                  op_id: BoolBinary_EqualTilde
                                                  left: {(DQ ($ VSub_Name "$varName"))}
                                                  right: 
                                                    {(Lit_Other "^") (Lit_Other "[") (a-zA-Z_) 
                                                      (Lit_Other "]") (Lit_Other "[") (a-zA-Z0-9_) (Lit_Other "]") (Lit_Other "*") (Lit_Other "$")
                                                    }
                                                )
                                            )
                                          ]
                                          negated: True
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {(echo)}
                                        {
                                          (DQ 
                                            (BracedVarSub
                                              token: <VSub_Name FUNCNAME>
                                              bracket_op: 
                                                (ArrayIndex
                                                  expr: (ArithWord w:{(Lit_Digits 0)})
                                                )
                                              spids: [2816 2821]
                                            ) ("(): WARNING: substitution variables should be valid bash names,")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: -1
                                          arg_word: {(2)}
                                          spids: [2825]
                                        )
                                      ]
                                    )
                                    (SimpleCommand
                                      words: [
                                        {(echo)}
                                        {
                                          (DQ ("  ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\\"">
                                            ) ($ VSub_Name "$varName") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                            (
" isn't and therefore was skipped; it might be caused"
                                            )
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: -1
                                          arg_word: {(2)}
                                          spids: [2839]
                                        )
                                      ]
                                    )
                                    (SimpleCommand
                                      words: [
                                        {(echo)}
                                        {
                                          (DQ 
                                            (
"  by multi-line phases in variables - see #14907 for details."
                                            )
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: -1
                                          arg_word: {(2)}
                                          spids: [2849]
                                        )
                                      ]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [-1 2810]
                                )
                              ]
                              spids: [-1 2856]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:pattern)
                                  op: Equal
                                  rhs: {(DQ ("@") ($ VSub_Name "$varName") ("@"))}
                                  spids: [2859]
                                )
                              ]
                              spids: [2859]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:replacement)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (BracedVarSub
                                          token: <VSub_Name varName>
                                          prefix_op: VSub_Bang
                                          spids: [2869 2872]
                                        )
                                      )
                                    }
                                  spids: [2867]
                                )
                              ]
                              spids: [2867]
                            )
                          ]
                          spids: [2764 2765 2876 -1]
                        )
                        (case_arm
                          pat_list: [{(--subst-var-by)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:pattern)
                                  op: Equal
                                  rhs: {(DQ ("@") ($ VSub_Number "$2") ("@"))}
                                  spids: [2884]
                                )
                              ]
                              spids: [2884]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:replacement)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number "$3"))}
                                  spids: [2892]
                                )
                              ]
                              spids: [2892]
                            )
                            (C {(shift)} {(3)})
                          ]
                          spids: [2880 2881 2903 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (SimpleCommand
                              words: [
                                {(echo)}
                                {
                                  (DQ 
                                    (BracedVarSub
                                      token: <VSub_Name FUNCNAME>
                                      bracket_op: (ArrayIndex expr:(ArithWord w:{(Lit_Digits 0)}))
                                      spids: [2914 2919]
                                    ) ("(): ERROR: Invalid command line argument: ") ($ VSub_Number "$1")
                                  )
                                }
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: -1
                                  arg_word: {(2)}
                                  spids: [2924]
                                )
                              ]
                            )
                            (ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(1)}
                            )
                          ]
                          spids: [2907 2908 2933 -1]
                        )
                      ]
                      spids: [2730 2736 2936]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:content)
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (BracedVarSub
                                  token: <VSub_Name content>
                                  suffix_op: 
                                    (PatSub
                                      pat: {(DQ ($ VSub_Name "$pattern"))}
                                      replace: {($ VSub_Name "$replacement")}
                                      do_all: True
                                      do_prefix: False
                                      do_suffix: False
                                    )
                                  spids: [2942 2951]
                                )
                              )
                            }
                          spids: [2940]
                        )
                      ]
                      spids: [2940]
                    )
                  ]
                  spids: [2727 2955]
                )
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-e)} {(DQ ($ VSub_Name "$output"))} {(Lit_Other "]")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Sentence
                      child: (C {(chmod)} {(Lit_Other "+") (w)} {(DQ ($ VSub_Name "$output"))})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  spids: [-1 2972]
                )
              ]
              spids: [-1 2984]
            )
            (SimpleCommand
              words: [{(printf)} {(DQ ("%s"))} {(DQ ($ VSub_Name "$content"))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$output"))}
                  spids: [2997]
                )
              ]
            )
          ]
          spids: [2581]
        )
      spids: [2577 2580]
    )
    (FuncDef
      name: substituteInPlace
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:fileName)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [3016]
                )
              ]
              spids: [3014]
            )
            (C {(shift)})
            (C {(substitute)} {(DQ ($ VSub_Name "$fileName"))} {(DQ ($ VSub_Name "$fileName"))} 
              {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [3011]
        )
      spids: [3007 3010]
    )
    (FuncDef
      name: substituteAll
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:input)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [3061]
                )
              ]
              spids: [3059]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:output)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$2"))}
                  spids: [3069]
                )
              ]
              spids: [3067]
            )
            (Assignment
              keyword: Assign_Local
              flags: ["'-a'"]
              pairs: [
                (assign_pair
                  lhs: (LhsName name:args)
                  op: Equal
                  rhs: {(ArrayLiteralPart)}
                  spids: [3079]
                )
              ]
              spids: [3075]
            )
            (ForEach
              iter_name: varName
              iter_words: [
                {
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [
                          (Pipeline
                            children: [
                              (C {(env)})
                              (C {(sed)} {(-e)} 
                                {
                                  (SQ <"s/^"> <Lit_EscapedChar "\\("> <"[a-z][^= "> 
                                    <Lit_EscapedChar "\\t"> <"]*"> <Lit_EscapedChar "\\)"> <"=.*/"> <Lit_EscapedChar "\\\\"> <"1/; t "> <Lit_EscapedChar "\\n"> <" d">
                                  )
                                }
                              )
                            ]
                            negated: False
                          )
                        ]
                      )
                    left_token: <Left_CommandSub "$(">
                    spids: [3095 3117]
                  )
                }
              ]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$NIX_DEBUG"))} {(Lit_Other "=")} 
                                  {(DQ (1))} {(Lit_Other "]")}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(echo)} 
                              {
                                (DQ ("@") (${ VSub_Name varName) ("@ -> '") 
                                  (BracedVarSub
                                    token: <VSub_Name varName>
                                    prefix_op: VSub_Bang
                                    spids: [3151 3154]
                                  ) ("'")
                                )
                              }
                            )
                          ]
                          spids: [-1 3140]
                        )
                      ]
                      spids: [-1 3159]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:args)
                          op: PlusEqual
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [{(DQ (--subst-var))} {(DQ ($ VSub_Name "$varName"))}]
                              )
                            }
                          spids: [3162]
                        )
                      ]
                      spids: [3162]
                    )
                  ]
                  spids: [3120 3174]
                )
              spids: [3094 3118]
            )
            (C {(substitute)} {(DQ ($ VSub_Name "$input"))} {(DQ ($ VSub_Name "$output"))} 
              {
                (DQ 
                  (BracedVarSub
                    token: <VSub_Name args>
                    bracket_op: (WholeArray op_id:Lit_At)
                    spids: [3189 3194]
                  )
                )
              }
            )
          ]
          spids: [3056]
        )
      spids: [3052 3055]
    )
    (FuncDef
      name: substituteAllInPlace
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:fileName)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [3210]
                )
              ]
              spids: [3208]
            )
            (C {(shift)})
            (C {(substituteAll)} {(DQ ($ VSub_Name "$fileName"))} {(DQ ($ VSub_Name "$fileName"))} 
              {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [3205]
        )
      spids: [3201 3204]
    )
    (FuncDef
      name: dumpVars
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$noDumpEnvVars"))} 
                          {(KW_Bang "!") (Lit_Other "=")} {(1)} {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (AndOr
                      children: [
                        (SimpleCommand
                          words: [{(export)}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: -1
                              arg_word: {(DQ ($ VSub_Name "$NIX_BUILD_TOP") (/env-vars))}
                              spids: [3288]
                            )
                          ]
                        )
                        (C {(true)})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [-1 3283]
                )
              ]
              spids: [-1 3300]
            )
          ]
          spids: [3264]
        )
      spids: [3260 3263]
    )
    (FuncDef
      name: stripHash
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [(assign_pair lhs:(LhsName name:strippedName) op:Equal spids:[3321])]
              spids: [3319]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:strippedName)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [(C {(basename)} {(DQ ($ VSub_Number "$1"))})]
                            )
                          left_token: <Left_CommandSub "$(">
                          spids: [3330 3336]
                        )
                      )
                    }
                  spids: [3328]
                )
              ]
              spids: [3328]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (Pipeline
                          children: [
                            (C {(echo)} {(DQ ($ VSub_Name "$strippedName"))})
                            (C {(grep)} {(-q)} {(SQ <"^[a-z0-9]\\{32\\}-">)})
                          ]
                          negated: False
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Pipeline
                      children: [(C {(echo)} {(DQ ($ VSub_Name "$strippedName"))}) (C {(cut)} {(-c34-)})]
                      negated: False
                    )
                  ]
                  spids: [-1 3359]
                )
              ]
              else_action: [(C {(echo)} {(DQ ($ VSub_Name "$strippedName"))})]
              spids: [3375 3385]
            )
          ]
          spids: [3316]
        )
      spids: [3312 3315]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:unpackCmdHooks)
          op: PlusEqual
          rhs: {(ArrayLiteralPart words:[{(_defaultUnpack)}])}
          spids: [3391]
        )
      ]
      spids: [3391]
    )
    (FuncDef
      name: _defaultUnpack
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:fn)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [3405]
                )
              ]
              spids: [3403]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (C {(Lit_Other "[")} {(-d)} {(DQ ($ VSub_Name "$fn"))} {(Lit_Other "]")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(cp)} {(-pr)} {(--reflink) (Lit_Other "=") (auto)} {(DQ ($ VSub_Name "$fn"))} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [(C {(stripHash)} {(DQ ($ VSub_Name "$fn"))})]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [3454 3460]
                          )
                        )
                      }
                    )
                  ]
                  spids: [-1 3425]
                )
              ]
              else_action: [
                (Case
                  to_match: {(DQ ($ VSub_Name "$fn"))}
                  arms: [
                    (case_arm
                      pat_list: [{(Lit_Other "*") (.tar.xz)} {(Lit_Other "*") (.tar.lzma)}]
                      action: [
                        (Pipeline
                          children: [
                            (SimpleCommand
                              words: [{(xz)} {(-d)}]
                              redirects: [
                                (Redir
                                  op_id: Redir_Less
                                  fd: -1
                                  arg_word: {(DQ ($ VSub_Name "$fn"))}
                                  spids: [3496]
                                )
                              ]
                            )
                            (C {(tar)} {(xf)} {(-)})
                          ]
                          negated: False
                        )
                      ]
                      spids: [3478 3485 3511 -1]
                    )
                    (case_arm
                      pat_list: [
                        {(Lit_Other "*") (.tar)}
                        {(Lit_Other "*") (.tar.) (Lit_Other "*")}
                        {(Lit_Other "*") (.tgz)}
                        {(Lit_Other "*") (.tbz2)}
                      ]
                      action: [(C {(tar)} {(xf)} {(DQ ($ VSub_Name "$fn"))})]
                      spids: [3514 3532 3552 -1]
                    )
                    (case_arm
                      pat_list: [{(Lit_Other "*")}]
                      action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})]
                      spids: [3555 3556 3564 -1]
                    )
                  ]
                  spids: [3469 3475 3567]
                )
              ]
              spids: [3465 3571]
            )
          ]
          spids: [3400]
        )
      spids: [3396 3399]
    )
    (FuncDef
      name: unpackFile
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:curSrc)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [3584]
                )
              ]
              spids: [3584]
            )
            (C {(header)} {(DQ ("unpacking source archive ") ($ VSub_Name "$curSrc"))} {(3)})
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (Pipeline
                          children: [(C {(runOneHook)} {(unpackCmd)} {(DQ ($ VSub_Name "$curSrc"))})]
                          negated: True
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(echo)} 
                      {(DQ ("do not know how to unpack source archive ") ($ VSub_Name "$curSrc"))}
                    )
                    (C {(exit)} {(1)})
                  ]
                  spids: [-1 3613]
                )
              ]
              spids: [-1 3629]
            )
          ]
          spids: [3581]
        )
      spids: [3577 3580]
    )
    (FuncDef
      name: unpackPhase
      body: 
        (BraceGroup
          children: [
            (C {(runHook)} {(preUnpack)})
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$srcs"))} {(Lit_Other "]")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$src"))} {(Lit_Other "]")})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(echo)} {(SQ <"variable $src or $srcs should point to the source">)})
                            (C {(exit)} {(1)})
                          ]
                          spids: [-1 3677]
                        )
                      ]
                      spids: [-1 3696]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:srcs)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$src"))}
                          spids: [3699]
                        )
                      ]
                      spids: [3699]
                    )
                  ]
                  spids: [-1 3661]
                )
              ]
              spids: [-1 3705]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [(assign_pair lhs:(LhsName name:dirsBefore) op:Equal rhs:{(DQ )} spids:[3727])]
              spids: [3725]
            )
            (ForEach
              iter_name: i
              iter_words: [{(Lit_Other "*")}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-d)} {(DQ ($ VSub_Name "$i"))} {(Lit_Other "]")})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:dirsBefore)
                                  op: Equal
                                  rhs: 
                                    {(DQ ($ VSub_Name "$dirsBefore") (" ") ($ VSub_Name "$i") (" "))}
                                  spids: [3760]
                                )
                              ]
                              spids: [3760]
                            )
                          ]
                          spids: [-1 3757]
                        )
                      ]
                      spids: [-1 3769]
                    )
                  ]
                  spids: [3741 3772]
                )
              spids: [3737 3739]
            )
            (ForEach
              iter_name: i
              iter_words: [{($ VSub_Name "$srcs")}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [(C {(unpackFile)} {(DQ ($ VSub_Name "$i"))})]
                  spids: [3789 3799]
                )
              spids: [3785 3787]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-n)} {(DQ ($ VSub_Name "$setSourceRoot"))} 
                          {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [(C {(runOneHook)} {(setSourceRoot)})]
                  spids: [-1 3820]
                )
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$sourceRoot"))} {(Lit_Other "]")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:sourceRoot)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [3844]
                        )
                      ]
                      spids: [3844]
                    )
                    (ForEach
                      iter_name: i
                      iter_words: [{(Lit_Other "*")}]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(Lit_Other "[")} {(-d)} {(DQ ($ VSub_Name "$i"))} 
                                          {(Lit_Other "]")}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Case
                                      to_match: {($ VSub_Name "$dirsBefore")}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other "*") 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\ ">
                                              ) ($ VSub_Name "$i") (EscapedLiteralPart token:<Lit_EscapedChar "\\ ">) (Lit_Other "*")
                                            }
                                          ]
                                          spids: [3882 3887 3890 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(Lit_Other "[")} {(-n)} 
                                                          {(DQ ($ VSub_Name "$sourceRoot"))} {(Lit_Other "]")}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (C {(echo)} 
                                                      {
                                                        (DQ 
                                                          (
"unpacker produced multiple directories"
                                                          )
                                                        )
                                                      }
                                                    )
                                                    (C {(exit)} {(1)})
                                                  ]
                                                  spids: [-1 3910]
                                                )
                                              ]
                                              spids: [-1 3925]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:sourceRoot)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$i"))}
                                                  spids: [3928]
                                                )
                                              ]
                                              spids: [3928]
                                            )
                                          ]
                                          spids: [3893 3894 3934 -1]
                                        )
                                      ]
                                      spids: [3875 3879 3937]
                                    )
                                  ]
                                  spids: [-1 3872]
                                )
                              ]
                              spids: [-1 3940]
                            )
                          ]
                          spids: [3856 3943]
                        )
                      spids: [3852 3854]
                    )
                  ]
                  spids: [3828 3841]
                )
              ]
              spids: [-1 3946]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$sourceRoot"))} {(Lit_Other "]")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(echo)} {(DQ ("unpacker appears to have produced no directories"))})
                    (C {(exit)} {(1)})
                  ]
                  spids: [-1 3963]
                )
              ]
              spids: [-1 3978]
            )
            (C {(echo)} {(DQ ("source root is ") ($ VSub_Name "$sourceRoot"))})
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$dontMakeSourcesWritable"))} 
                          {(KW_Bang "!") (Lit_Other "=")} {(1)} {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(chmod)} {(-R)} {(u) (Lit_Other "+") (w)} {(DQ ($ VSub_Name "$sourceRoot"))})
                  ]
                  spids: [-1 4019]
                )
              ]
              spids: [-1 4035]
            )
            (C {(runHook)} {(postUnpack)})
          ]
          spids: [3639]
        )
      spids: [3635 3638]
    )
    (FuncDef
      name: patchPhase
      body: 
        (BraceGroup
          children: [
            (C {(runHook)} {(prePatch)})
            (ForEach
              iter_name: i
              iter_words: [{($ VSub_Name "$patches")}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (C {(header)} {(DQ ("applying patch ") ($ VSub_Name "$i"))} {(3)})
                    (Assignment
                      keyword: Assign_Local
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:uncompress)
                          op: Equal
                          rhs: {(cat)}
                          spids: [4084]
                        )
                      ]
                      spids: [4082]
                    )
                    (Case
                      to_match: {(DQ ($ VSub_Name "$i"))}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Other "*") (.gz)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:uncompress)
                                  op: Equal
                                  rhs: {(DQ ("gzip -d"))}
                                  spids: [4102]
                                )
                              ]
                              spids: [4102]
                            )
                          ]
                          spids: [4097 4099 4108 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*") (.bz2)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:uncompress)
                                  op: Equal
                                  rhs: {(DQ ("bzip2 -d"))}
                                  spids: [4116]
                                )
                              ]
                              spids: [4116]
                            )
                          ]
                          spids: [4111 4113 4122 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*") (.xz)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:uncompress)
                                  op: Equal
                                  rhs: {(DQ ("xz -d"))}
                                  spids: [4130]
                                )
                              ]
                              spids: [4130]
                            )
                          ]
                          spids: [4125 4127 4136 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*") (.lzma)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:uncompress)
                                  op: Equal
                                  rhs: {(DQ ("lzma -d"))}
                                  spids: [4144]
                                )
                              ]
                              spids: [4144]
                            )
                          ]
                          spids: [4139 4141 4150 -1]
                        )
                      ]
                      spids: [4088 4094 4153]
                    )
                    (Pipeline
                      children: [
                        (SimpleCommand
                          words: [{($ VSub_Name "$uncompress")}]
                          redirects: [
                            (Redir
                              op_id: Redir_Less
                              fd: -1
                              arg_word: {(DQ ($ VSub_Name "$i"))}
                              spids: [4166]
                            )
                            (Redir
                              op_id: Redir_GreatAnd
                              fd: 2
                              arg_word: {(1)}
                              spids: [4172]
                            )
                          ]
                        )
                        (C {(patch)} 
                          {
                            (BracedVarSub
                              token: <VSub_Name patchFlags>
                              suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(-p1)})
                              spids: [4179 4183]
                            )
                          }
                        )
                      ]
                      negated: False
                    )
                  ]
                  spids: [4069 4186]
                )
              spids: [4065 4067]
            )
            (C {(runHook)} {(postPatch)})
          ]
          spids: [4051]
        )
      spids: [4047 4050]
    )
    (FuncDef
      name: fixLibtool
      body: 
        (BraceGroup
          children: [
            (C {(sed)} {(-i)} {(-e)} {(SQ <"s^eval sys_lib_.*search_path=.*^^">)} 
              {(DQ ($ VSub_Number "$1"))}
            )
          ]
          spids: [4202]
        )
      spids: [4198 4201]
    )
    (FuncDef
      name: configurePhase
      body: 
        (BraceGroup
          children: [
            (C {(runHook)} {(preConfigure)})
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (LogicalAnd
                              left: 
                                (BoolUnary
                                  op_id: BoolUnary_z
                                  child: {(DQ ($ VSub_Name "$configureScript"))}
                                )
                              right: (BoolUnary op_id:BoolUnary_x child:{(./configure)})
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:configureScript)
                          op: Equal
                          rhs: {(./configure)}
                          spids: [4258]
                        )
                      ]
                      spids: [4258]
                    )
                  ]
                  spids: [-1 4255]
                )
              ]
              spids: [-1 4262]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$dontFixLibtool"))} 
                          {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_Local
                      pairs: [(assign_pair lhs:(LhsName name:i) op:Equal spids:[4284])]
                      spids: [4282]
                    )
                    (Pipeline
                      children: [
                        (C {(find)} {(.)} {(-iname)} {(DQ (ltmain.sh))} {(-print0)})
                        (While
                          cond: [
                            (Sentence
                              child: 
                                (SimpleCommand
                                  words: [{(read)} {(-r)} {(-d)} {(SQ )} {(i)}]
                                  more_env: [(env_pair name:IFS val:{(SQ )} spids:[4303])]
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          body: 
                            (DoGroup
                              children: [
                                (C {(echo)} {(DQ ("fixing libtool script ") ($ VSub_Name "$i"))})
                                (C {(fixLibtool)} {(DQ ($ VSub_Name "$i"))})
                              ]
                              spids: [4319 4337]
                            )
                        )
                      ]
                      negated: False
                    )
                  ]
                  spids: [-1 4279]
                )
              ]
              spids: [-1 4340]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (LogicalAnd
                              left: 
                                (BoolUnary
                                  op_id: BoolUnary_z
                                  child: {(DQ ($ VSub_Name "$dontAddPrefix"))}
                                )
                              right: (BoolUnary op_id:BoolUnary_n child:{(DQ ($ VSub_Name "$prefix"))})
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:configureFlags)
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (BracedVarSub
                                  token: <VSub_Name prefixKey>
                                  suffix_op: 
                                    (StringUnary
                                      op_id: VTest_ColonHyphen
                                      arg_word: {("--prefix=")}
                                    )
                                  spids: [4370 4374]
                                ) ($ VSub_Name "$prefix") (" ") ($ VSub_Name "$configureFlags")
                              )
                            }
                          spids: [4368]
                        )
                      ]
                      spids: [4368]
                    )
                  ]
                  spids: [-1 4365]
                )
              ]
              spids: [-1 4381]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$dontAddDisableDepTrack"))} 
                          {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (AndOr
                                  children: [
                                    (C {(Lit_Other "[")} {(-f)} {(DQ ($ VSub_Name "$configureScript"))} 
                                      {(Lit_Other "]")}
                                    )
                                    (C {(grep)} {(-q)} {(dependency-tracking)} 
                                      {(DQ ($ VSub_Name "$configureScript"))}
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:configureFlags)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ("--disable-dependency-tracking ") 
                                        ($ VSub_Name "$configureFlags")
                                      )
                                    }
                                  spids: [4433]
                                )
                              ]
                              spids: [4433]
                            )
                          ]
                          spids: [-1 4430]
                        )
                      ]
                      spids: [-1 4440]
                    )
                  ]
                  spids: [-1 4402]
                )
              ]
              spids: [-1 4443]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$dontDisableStatic"))} 
                          {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (AndOr
                                  children: [
                                    (C {(Lit_Other "[")} {(-f)} {(DQ ($ VSub_Name "$configureScript"))} 
                                      {(Lit_Other "]")}
                                    )
                                    (C {(grep)} {(-q)} {(enable-static)} 
                                      {(DQ ($ VSub_Name "$configureScript"))}
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:configureFlags)
                                  op: Equal
                                  rhs: {(DQ ("--disable-static ") ($ VSub_Name "$configureFlags"))}
                                  spids: [4495]
                                )
                              ]
                              spids: [4495]
                            )
                          ]
                          spids: [-1 4492]
                        )
                      ]
                      spids: [-1 4502]
                    )
                  ]
                  spids: [-1 4464]
                )
              ]
              spids: [-1 4505]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-n)} {(DQ ($ VSub_Name "$configureScript"))} 
                          {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_Local
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:flagsArray)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {($ VSub_Name "$configureFlags")}
                                  {
                                    (DQ 
                                      (BracedVarSub
                                        token: <VSub_Name configureFlagsArray>
                                        bracket_op: (WholeArray op_id:Lit_At)
                                        spids: [4536 4541]
                                      )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [4531]
                        )
                      ]
                      spids: [4529]
                    )
                    (C {(echoCmd)} {(SQ <"configure flags">)} 
                      {
                        (DQ 
                          (BracedVarSub
                            token: <VSub_Name flagsArray>
                            bracket_op: (WholeArray op_id:Lit_At)
                            spids: [4553 4558]
                          )
                        )
                      }
                    )
                    (C {($ VSub_Name "$configureScript")} 
                      {
                        (DQ 
                          (BracedVarSub
                            token: <VSub_Name flagsArray>
                            bracket_op: (WholeArray op_id:Lit_At)
                            spids: [4569 4574]
                          )
                        )
                      }
                    )
                    (C {(unset)} {(flagsArray)})
                  ]
                  spids: [-1 4522]
                )
              ]
              else_action: [(C {(echo)} {(DQ ("no configure script, doing nothing"))})]
              spids: [4583 4593]
            )
            (C {(runHook)} {(postConfigure)})
          ]
          spids: [4227]
        )
      spids: [4223 4226]
    )
    (FuncDef
      name: buildPhase
      body: 
        (BraceGroup
          children: [
            (C {(runHook)} {(preBuild)})
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (LogicalAnd
                              left: 
                                (BoolUnary
                                  op_id: BoolUnary_z
                                  child: {(DQ ($ VSub_Name "$makeFlags"))}
                                )
                              right: 
                                (LogicalNot
                                  child: 
                                    (LogicalOr
                                      left: 
                                        (BoolUnary
                                          op_id: BoolUnary_n
                                          child: {(DQ ($ VSub_Name "$makefile"))}
                                        )
                                      right: 
                                        (LogicalOr
                                          left: (BoolUnary op_id:BoolUnary_e child:{(Makefile)})
                                          right: 
                                            (LogicalOr
                                              left: (BoolUnary op_id:BoolUnary_e child:{(makefile)})
                                              right: 
                                                (BoolUnary
                                                  op_id: BoolUnary_e
                                                  child: 
                                                    {(GNUmakefile) (Lit_Other "[") (Lit_Other "[")}
                                                )
                                            )
                                        )
                                    )
                                )
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [(C {(echo)} {(DQ ("no Makefile, doing nothing"))})]
                  spids: [-1 4665]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:makeFlags)
                      op: Equal
                      rhs: {(DQ ("SHELL=") ($ VSub_Name "$SHELL") (" ") ($ VSub_Name "$makeFlags"))}
                      spids: [4682]
                    )
                  ]
                  spids: [4682]
                )
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:flagsArray)
                      op: Equal
                      rhs: 
                        {
                          (ArrayLiteralPart
                            words: [
                              {
                                (BracedVarSub
                                  token: <VSub_Name enableParallelBuilding>
                                  suffix_op: 
                                    (StringUnary
                                      op_id: VTest_ColonPlus
                                      arg_word: 
                                        {(-j) (${ VSub_Name NIX_BUILD_CORES) (" -l") 
                                          (${ VSub_Name NIX_BUILD_CORES)
                                        }
                                    )
                                  spids: [4703 4714]
                                )
                              }
                              {($ VSub_Name "$makeFlags")}
                              {
                                (DQ 
                                  (BracedVarSub
                                    token: <VSub_Name makeFlagsArray>
                                    bracket_op: (WholeArray op_id:Lit_At)
                                    spids: [4721 4726]
                                  )
                                )
                              }
                              {($ VSub_Name "$buildFlags")}
                              {
                                (DQ 
                                  (BracedVarSub
                                    token: <VSub_Name buildFlagsArray>
                                    bracket_op: (WholeArray op_id:Lit_At)
                                    spids: [4734 4739]
                                  )
                                )
                              }
                            ]
                          )
                        }
                      spids: [4698]
                    )
                  ]
                  spids: [4696]
                )
                (C {(echoCmd)} {(SQ <"build flags">)} 
                  {
                    (DQ 
                      (BracedVarSub
                        token: <VSub_Name flagsArray>
                        bracket_op: (WholeArray op_id:Lit_At)
                        spids: [4752 4757]
                      )
                    )
                  }
                )
                (C {(make)} 
                  {
                    (BracedVarSub
                      token: <VSub_Name makefile>
                      suffix_op: 
                        (StringUnary
                          op_id: VTest_ColonPlus
                          arg_word: {("-f ") ($ VSub_Name "$makefile")}
                        )
                      spids: [4763 4768]
                    )
                  } 
                  {
                    (DQ 
                      (BracedVarSub
                        token: <VSub_Name flagsArray>
                        bracket_op: (WholeArray op_id:Lit_At)
                        spids: [4771 4776]
                      )
                    )
                  }
                )
                (C {(unset)} {(flagsArray)})
              ]
              spids: [4675 4785]
            )
            (C {(runHook)} {(postBuild)})
          ]
          spids: [4609]
        )
      spids: [4605 4608]
    )
    (FuncDef
      name: checkPhase
      body: 
        (BraceGroup
          children: [
            (C {(runHook)} {(preCheck)})
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:flagsArray)
                  op: Equal
                  rhs: 
                    {
                      (ArrayLiteralPart
                        words: [
                          {
                            (BracedVarSub
                              token: <VSub_Name enableParallelBuilding>
                              suffix_op: 
                                (StringUnary
                                  op_id: VTest_ColonPlus
                                  arg_word: 
                                    {(-j) (${ VSub_Name NIX_BUILD_CORES) (" -l") 
                                      (${ VSub_Name NIX_BUILD_CORES)
                                    }
                                )
                              spids: [4821 4832]
                            )
                          }
                          {($ VSub_Name "$makeFlags")}
                          {
                            (DQ 
                              (BracedVarSub
                                token: <VSub_Name makeFlagsArray>
                                bracket_op: (WholeArray op_id:Lit_At)
                                spids: [4839 4844]
                              )
                            )
                          }
                          {
                            (BracedVarSub
                              token: <VSub_Name checkFlags>
                              suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{("VERBOSE=y")})
                              spids: [4849 4853]
                            )
                          }
                          {
                            (DQ 
                              (BracedVarSub
                                token: <VSub_Name checkFlagsArray>
                                bracket_op: (WholeArray op_id:Lit_At)
                                spids: [4856 4861]
                              )
                            )
                          }
                          {
                            (BracedVarSub
                              token: <VSub_Name checkTarget>
                              suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(check)})
                              spids: [4864 4868]
                            )
                          }
                        ]
                      )
                    }
                  spids: [4816]
                )
              ]
              spids: [4814]
            )
            (C {(echoCmd)} {(SQ <"check flags">)} 
              {
                (DQ 
                  (BracedVarSub
                    token: <VSub_Name flagsArray>
                    bracket_op: (WholeArray op_id:Lit_At)
                    spids: [4880 4885]
                  )
                )
              }
            )
            (C {(make)} 
              {
                (BracedVarSub
                  token: <VSub_Name makefile>
                  suffix_op: 
                    (StringUnary
                      op_id: VTest_ColonPlus
                      arg_word: {("-f ") ($ VSub_Name "$makefile")}
                    )
                  spids: [4891 4896]
                )
              } 
              {
                (DQ 
                  (BracedVarSub
                    token: <VSub_Name flagsArray>
                    bracket_op: (WholeArray op_id:Lit_At)
                    spids: [4899 4904]
                  )
                )
              }
            )
            (C {(unset)} {(flagsArray)})
            (C {(runHook)} {(postCheck)})
          ]
          spids: [4801]
        )
      spids: [4797 4800]
    )
    (FuncDef
      name: installPhase
      body: 
        (BraceGroup
          children: [
            (C {(runHook)} {(preInstall)})
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-n)} {(DQ ($ VSub_Name "$prefix"))} {(Lit_Other "]")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [(C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$prefix"))})]
                  spids: [-1 4948]
                )
              ]
              spids: [-1 4960]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:installTargets)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (BracedVarSub
                          token: <VSub_Name installTargets>
                          suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(install)})
                          spids: [4966 4970]
                        )
                      )
                    }
                  spids: [4964]
                )
              ]
              spids: [4964]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:flagsArray)
                  op: Equal
                  rhs: 
                    {
                      (ArrayLiteralPart
                        words: [
                          {($ VSub_Name "$installTargets")}
                          {($ VSub_Name "$makeFlags")}
                          {
                            (DQ 
                              (BracedVarSub
                                token: <VSub_Name makeFlagsArray>
                                bracket_op: (WholeArray op_id:Lit_At)
                                spids: [4991 4996]
                              )
                            )
                          }
                          {($ VSub_Name "$installFlags")}
                          {
                            (DQ 
                              (BracedVarSub
                                token: <VSub_Name installFlagsArray>
                                bracket_op: (WholeArray op_id:Lit_At)
                                spids: [5004 5009]
                              )
                            )
                          }
                        ]
                      )
                    }
                  spids: [4981]
                )
              ]
              spids: [4979]
            )
            (C {(echoCmd)} {(SQ <"install flags">)} 
              {
                (DQ 
                  (BracedVarSub
                    token: <VSub_Name flagsArray>
                    bracket_op: (WholeArray op_id:Lit_At)
                    spids: [5022 5027]
                  )
                )
              }
            )
            (C {(make)} 
              {
                (BracedVarSub
                  token: <VSub_Name makefile>
                  suffix_op: 
                    (StringUnary
                      op_id: VTest_ColonPlus
                      arg_word: {("-f ") ($ VSub_Name "$makefile")}
                    )
                  spids: [5033 5038]
                )
              } 
              {
                (DQ 
                  (BracedVarSub
                    token: <VSub_Name flagsArray>
                    bracket_op: (WholeArray op_id:Lit_At)
                    spids: [5041 5046]
                  )
                )
              }
            )
            (C {(unset)} {(flagsArray)})
            (C {(runHook)} {(postInstall)})
          ]
          spids: [4926]
        )
      spids: [4922 4925]
    )
    (FuncDef
      name: fixupPhase
      body: 
        (BraceGroup
          children: [
            (ForEach
              iter_name: output
              iter_words: [{($ VSub_Name "$outputs")}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-e)} 
                                  {
                                    (DQ 
                                      (BracedVarSub
                                        token: <VSub_Name output>
                                        prefix_op: VSub_Bang
                                        spids: [5103 5106]
                                      )
                                    )
                                  } {(Lit_Other "]")}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Sentence
                              child: 
                                (C {(chmod)} {(-R)} {(u) (Lit_Other "+") (w)} 
                                  {
                                    (DQ 
                                      (BracedVarSub
                                        token: <VSub_Name output>
                                        prefix_op: VSub_Bang
                                        spids: [5123 5126]
                                      )
                                    )
                                  }
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          spids: [-1 5112]
                        )
                      ]
                      spids: [-1 5130]
                    )
                  ]
                  spids: [5093 5133]
                )
              spids: [5089 5091]
            )
            (C {(runHook)} {(preFixup)})
            (Assignment
              keyword: Assign_Local
              pairs: [(assign_pair lhs:(LhsName name:output) op:Equal spids:[5149])]
              spids: [5147]
            )
            (ForEach
              iter_name: output
              iter_words: [{($ VSub_Name "$outputs")}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (SimpleCommand
                      words: [{(runHook)} {(fixupOutput)}]
                      more_env: [
                        (env_pair
                          name: prefix
                          val: 
                            {
                              (DQ 
                                (BracedVarSub
                                  token: <VSub_Name output>
                                  prefix_op: VSub_Bang
                                  spids: [5166 5169]
                                )
                              )
                            }
                          spids: [5164]
                        )
                      ]
                    )
                  ]
                  spids: [5161 5177]
                )
              spids: [5157 5159]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$crossConfig"))} {(Lit_Other "]")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_Local
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:propagated)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$propagatedNativeBuildInputs"))}
                          spids: [5209]
                        )
                      ]
                      spids: [5207]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-n)} {(DQ ($ VSub_Name "$propagatedBuildInputs"))} 
                                  {(Lit_Other "]")}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:propagated)
                                  op: PlusEqual
                                  rhs: 
                                    {
                                      (DQ 
                                        (BracedVarSub
                                          token: <VSub_Name propagated>
                                          suffix_op: 
                                            (StringUnary
                                              op_id: VTest_ColonPlus
                                              arg_word: {(" ")}
                                            )
                                          spids: [5233 5237]
                                        ) ($ VSub_Name "$propagatedBuildInputs")
                                      )
                                    }
                                  spids: [5231]
                                )
                              ]
                              spids: [5231]
                            )
                          ]
                          spids: [-1 5228]
                        )
                      ]
                      spids: [-1 5242]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-n)} {(DQ ($ VSub_Name "$propagated"))} 
                                  {(Lit_Other "]")}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(mkdir)} {(-p)} 
                              {
                                (DQ 
                                  (BracedVarSub
                                    token: <VSub_Name outputDev>
                                    prefix_op: VSub_Bang
                                    spids: [5266 5269]
                                  ) (/nix-support)
                                )
                              }
                            )
                            (SimpleCommand
                              words: [{(printWords)} {($ VSub_Name "$propagated")}]
                              redirects: [
                                (Redir
                                  op_id: Redir_Great
                                  fd: -1
                                  arg_word: 
                                    {
                                      (DQ 
                                        (BracedVarSub
                                          token: <VSub_Name outputDev>
                                          prefix_op: VSub_Bang
                                          spids: [5285 5288]
                                        ) (/nix-support/propagated-native-build-inputs)
                                      )
                                    }
                                  spids: [5282]
                                )
                              ]
                            )
                          ]
                          spids: [-1 5258]
                        )
                      ]
                      spids: [-1 5293]
                    )
                  ]
                  spids: [-1 5200]
                )
              ]
              else_action: [
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (C {(Lit_Other "[")} {(-n)} {(DQ ($ VSub_Name "$propagatedBuildInputs"))} 
                              {(Lit_Other "]")}
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (C {(mkdir)} {(-p)} 
                          {
                            (DQ 
                              (BracedVarSub
                                token: <VSub_Name outputDev>
                                prefix_op: VSub_Bang
                                spids: [5320 5323]
                              ) (/nix-support)
                            )
                          }
                        )
                        (SimpleCommand
                          words: [{(printWords)} {($ VSub_Name "$propagatedBuildInputs")}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: -1
                              arg_word: 
                                {
                                  (DQ 
                                    (BracedVarSub
                                      token: <VSub_Name outputDev>
                                      prefix_op: VSub_Bang
                                      spids: [5339 5342]
                                    ) (/nix-support/propagated-build-inputs)
                                  )
                                }
                              spids: [5336]
                            )
                          ]
                        )
                      ]
                      spids: [-1 5312]
                    )
                  ]
                  spids: [-1 5347]
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (C {(Lit_Other "[")} {(-n)} 
                              {(DQ ($ VSub_Name "$propagatedNativeBuildInputs"))} {(Lit_Other "]")}
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (C {(mkdir)} {(-p)} 
                          {
                            (DQ 
                              (BracedVarSub
                                token: <VSub_Name outputDev>
                                prefix_op: VSub_Bang
                                spids: [5372 5375]
                              ) (/nix-support)
                            )
                          }
                        )
                        (SimpleCommand
                          words: [{(printWords)} {($ VSub_Name "$propagatedNativeBuildInputs")}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: -1
                              arg_word: 
                                {
                                  (DQ 
                                    (BracedVarSub
                                      token: <VSub_Name outputDev>
                                      prefix_op: VSub_Bang
                                      spids: [5391 5394]
                                    ) (/nix-support/propagated-native-build-inputs)
                                  )
                                }
                              spids: [5388]
                            )
                          ]
                        )
                      ]
                      spids: [-1 5364]
                    )
                  ]
                  spids: [-1 5399]
                )
              ]
              spids: [5296 5402]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-n)} {(DQ ($ VSub_Name "$setupHook"))} {(Lit_Other "]")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(mkdir)} {(-p)} 
                      {
                        (DQ 
                          (BracedVarSub
                            token: <VSub_Name outputDev>
                            prefix_op: VSub_Bang
                            spids: [5427 5430]
                          ) (/nix-support)
                        )
                      }
                    )
                    (C {(substituteAll)} {(DQ ($ VSub_Name "$setupHook"))} 
                      {
                        (DQ 
                          (BracedVarSub
                            token: <VSub_Name outputDev>
                            prefix_op: VSub_Bang
                            spids: [5442 5445]
                          ) (/nix-support/setup-hook)
                        )
                      }
                    )
                  ]
                  spids: [-1 5419]
                )
              ]
              spids: [-1 5450]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-n)} {(DQ ($ VSub_Name "$propagatedUserEnvPkgs"))} 
                          {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(mkdir)} {(-p)} 
                      {
                        (DQ 
                          (BracedVarSub
                            token: <VSub_Name outputBin>
                            prefix_op: VSub_Bang
                            spids: [5480 5483]
                          ) (/nix-support)
                        )
                      }
                    )
                    (SimpleCommand
                      words: [{(printWords)} {($ VSub_Name "$propagatedUserEnvPkgs")}]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: 
                            {
                              (DQ 
                                (BracedVarSub
                                  token: <VSub_Name outputBin>
                                  prefix_op: VSub_Bang
                                  spids: [5499 5502]
                                ) (/nix-support/propagated-user-env-packages)
                              )
                            }
                          spids: [5496]
                        )
                      ]
                    )
                  ]
                  spids: [-1 5472]
                )
              ]
              spids: [-1 5507]
            )
            (C {(runHook)} {(postFixup)})
          ]
          spids: [5077]
        )
      spids: [5073 5076]
    )
    (FuncDef
      name: installCheckPhase
      body: 
        (BraceGroup
          children: [
            (C {(runHook)} {(preInstallCheck)})
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:flagsArray)
                  op: Equal
                  rhs: 
                    {
                      (ArrayLiteralPart
                        words: [
                          {
                            (BracedVarSub
                              token: <VSub_Name enableParallelBuilding>
                              suffix_op: 
                                (StringUnary
                                  op_id: VTest_ColonPlus
                                  arg_word: 
                                    {(-j) (${ VSub_Name NIX_BUILD_CORES) (" -l") 
                                      (${ VSub_Name NIX_BUILD_CORES)
                                    }
                                )
                              spids: [5543 5554]
                            )
                          }
                          {($ VSub_Name "$makeFlags")}
                          {
                            (DQ 
                              (BracedVarSub
                                token: <VSub_Name makeFlagsArray>
                                bracket_op: (WholeArray op_id:Lit_At)
                                spids: [5561 5566]
                              )
                            )
                          }
                          {($ VSub_Name "$installCheckFlags")}
                          {
                            (DQ 
                              (BracedVarSub
                                token: <VSub_Name installCheckFlagsArray>
                                bracket_op: (WholeArray op_id:Lit_At)
                                spids: [5574 5579]
                              )
                            )
                          }
                          {
                            (BracedVarSub
                              token: <VSub_Name installCheckTarget>
                              suffix_op: 
                                (StringUnary
                                  op_id: VTest_ColonHyphen
                                  arg_word: {(installcheck)}
                                )
                              spids: [5582 5586]
                            )
                          }
                        ]
                      )
                    }
                  spids: [5538]
                )
              ]
              spids: [5536]
            )
            (C {(echoCmd)} {(SQ <"installcheck flags">)} 
              {
                (DQ 
                  (BracedVarSub
                    token: <VSub_Name flagsArray>
                    bracket_op: (WholeArray op_id:Lit_At)
                    spids: [5598 5603]
                  )
                )
              }
            )
            (C {(make)} 
              {
                (BracedVarSub
                  token: <VSub_Name makefile>
                  suffix_op: 
                    (StringUnary
                      op_id: VTest_ColonPlus
                      arg_word: {("-f ") ($ VSub_Name "$makefile")}
                    )
                  spids: [5609 5614]
                )
              } 
              {
                (DQ 
                  (BracedVarSub
                    token: <VSub_Name flagsArray>
                    bracket_op: (WholeArray op_id:Lit_At)
                    spids: [5617 5622]
                  )
                )
              }
            )
            (C {(unset)} {(flagsArray)})
            (C {(runHook)} {(postInstallCheck)})
          ]
          spids: [5523]
        )
      spids: [5519 5522]
    )
    (FuncDef
      name: distPhase
      body: 
        (BraceGroup
          children: [
            (C {(runHook)} {(preDist)})
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:flagsArray)
                  op: Equal
                  rhs: 
                    {
                      (ArrayLiteralPart
                        words: [
                          {($ VSub_Name "$distFlags")}
                          {
                            (DQ 
                              (BracedVarSub
                                token: <VSub_Name distFlagsArray>
                                bracket_op: (WholeArray op_id:Lit_At)
                                spids: [5664 5669]
                              )
                            )
                          }
                          {
                            (BracedVarSub
                              token: <VSub_Name distTarget>
                              suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(dist)})
                              spids: [5672 5676]
                            )
                          }
                        ]
                      )
                    }
                  spids: [5659]
                )
              ]
              spids: [5657]
            )
            (C {(echo)} {(SQ <"dist flags: %q">)} 
              {
                (DQ 
                  (BracedVarSub
                    token: <VSub_Name flagsArray>
                    bracket_op: (WholeArray op_id:Lit_At)
                    spids: [5688 5693]
                  )
                )
              }
            )
            (C {(make)} 
              {
                (BracedVarSub
                  token: <VSub_Name makefile>
                  suffix_op: 
                    (StringUnary
                      op_id: VTest_ColonPlus
                      arg_word: {("-f ") ($ VSub_Name "$makefile")}
                    )
                  spids: [5699 5704]
                )
              } 
              {
                (DQ 
                  (BracedVarSub
                    token: <VSub_Name flagsArray>
                    bracket_op: (WholeArray op_id:Lit_At)
                    spids: [5707 5712]
                  )
                )
              }
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$dontCopyDist"))} 
                          {(KW_Bang "!") (Lit_Other "=")} {(1)} {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$out") (/tarballs))})
                    (C {(cp)} {(-pvd)} 
                      {
                        (BracedVarSub
                          token: <VSub_Name tarballs>
                          suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{("*.tar.gz")})
                          spids: [5763 5767]
                        )
                      } {(DQ ($ VSub_Name "$out") (/tarballs))}
                    )
                  ]
                  spids: [-1 5733]
                )
              ]
              spids: [-1 5775]
            )
            (C {(runHook)} {(postDist)})
          ]
          spids: [5644]
        )
      spids: [5640 5643]
    )
    (FuncDef
      name: showPhaseHeader
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:phase)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [5796]
                )
              ]
              spids: [5794]
            )
            (Case
              to_match: {(DQ ($ VSub_Name "$phase"))}
              arms: [
                (case_arm
                  pat_list: [{(unpackPhase)}]
                  action: [(C {(header)} {(DQ ("unpacking sources"))})]
                  spids: [5811 5812 5819 -1]
                )
                (case_arm
                  pat_list: [{(patchPhase)}]
                  action: [(C {(header)} {(DQ ("patching sources"))})]
                  spids: [5822 5823 5830 -1]
                )
                (case_arm
                  pat_list: [{(configurePhase)}]
                  action: [(C {(header)} {(DQ (configuring))})]
                  spids: [5833 5834 5841 -1]
                )
                (case_arm
                  pat_list: [{(buildPhase)}]
                  action: [(C {(header)} {(DQ (building))})]
                  spids: [5844 5845 5852 -1]
                )
                (case_arm
                  pat_list: [{(checkPhase)}]
                  action: [(C {(header)} {(DQ ("running tests"))})]
                  spids: [5855 5856 5863 -1]
                )
                (case_arm
                  pat_list: [{(installPhase)}]
                  action: [(C {(header)} {(DQ (installing))})]
                  spids: [5866 5867 5874 -1]
                )
                (case_arm
                  pat_list: [{(fixupPhase)}]
                  action: [(C {(header)} {(DQ ("post-installation fixup"))})]
                  spids: [5877 5878 5885 -1]
                )
                (case_arm
                  pat_list: [{(installCheckPhase)}]
                  action: [(C {(header)} {(DQ ("running install tests"))})]
                  spids: [5888 5889 5896 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [(C {(header)} {(DQ ($ VSub_Name "$phase"))})]
                  spids: [5899 5900 5907 -1]
                )
              ]
              spids: [5802 5808 5910]
            )
          ]
          spids: [5791]
        )
      spids: [5787 5790]
    )
    (FuncDef
      name: genericBuild
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-f)} {(DQ ($ VSub_Name "$buildCommandPath"))} 
                          {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(.)} {(DQ ($ VSub_Name "$buildCommandPath"))})
                    (ControlFlow token:<ControlFlow_Return return>)
                  ]
                  spids: [-1 5936]
                )
              ]
              spids: [-1 5949]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-n)} {(DQ ($ VSub_Name "$buildCommand"))} 
                          {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(eval)} {(DQ ($ VSub_Name "$buildCommand"))})
                    (ControlFlow token:<ControlFlow_Return return>)
                  ]
                  spids: [-1 5965]
                )
              ]
              spids: [-1 5978]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$phases"))} {(Lit_Other "]")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:phases)
                              op: Equal
                              rhs: 
                                {
                                  (DQ ($ VSub_Name "$prePhases") (" unpackPhase patchPhase ") 
                                    ($ VSub_Name "$preConfigurePhases") (" ") ("            configurePhase ") ($ VSub_Name "$preBuildPhases") (" buildPhase checkPhase ") 
                                    ("            ") ($ VSub_Name "$preInstallPhases") (" installPhase ") ($ VSub_Name "$preFixupPhases") 
                                    (" fixupPhase installCheckPhase ") ("            ") ($ VSub_Name "$preDistPhases") (" distPhase ") ($ VSub_Name "$postPhases")
                                  )
                                }
                              spids: [5998]
                            )
                          ]
                          spids: [5998]
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  spids: [-1 5995]
                )
              ]
              spids: [-1 6023]
            )
            (ForEach
              iter_name: curPhase
              iter_words: [{($ VSub_Name "$phases")}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (LogicalAnd
                                      left: 
                                        (BoolBinary
                                          op_id: BoolBinary_GlobEqual
                                          left: {(DQ ($ VSub_Name "$curPhase"))}
                                          right: {(buildPhase)}
                                        )
                                      right: 
                                        (BoolUnary
                                          op_id: BoolUnary_n
                                          child: {(DQ ($ VSub_Name "$dontBuild"))}
                                        )
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Sentence
                              child: (ControlFlow token:<ControlFlow_Continue continue>)
                              terminator: <Op_Semi ";">
                            )
                          ]
                          spids: [-1 6062]
                        )
                      ]
                      spids: [-1 6067]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (LogicalAnd
                                      left: 
                                        (BoolBinary
                                          op_id: BoolBinary_GlobEqual
                                          left: {(DQ ($ VSub_Name "$curPhase"))}
                                          right: {(checkPhase)}
                                        )
                                      right: 
                                        (BoolUnary
                                          op_id: BoolUnary_z
                                          child: {(DQ ($ VSub_Name "$doCheck"))}
                                        )
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Sentence
                              child: (ControlFlow token:<ControlFlow_Continue continue>)
                              terminator: <Op_Semi ";">
                            )
                          ]
                          spids: [-1 6093]
                        )
                      ]
                      spids: [-1 6098]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (LogicalAnd
                                      left: 
                                        (BoolBinary
                                          op_id: BoolBinary_GlobEqual
                                          left: {(DQ ($ VSub_Name "$curPhase"))}
                                          right: {(installPhase)}
                                        )
                                      right: 
                                        (BoolUnary
                                          op_id: BoolUnary_n
                                          child: {(DQ ($ VSub_Name "$dontInstall"))}
                                        )
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Sentence
                              child: (ControlFlow token:<ControlFlow_Continue continue>)
                              terminator: <Op_Semi ";">
                            )
                          ]
                          spids: [-1 6124]
                        )
                      ]
                      spids: [-1 6129]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (LogicalAnd
                                      left: 
                                        (BoolBinary
                                          op_id: BoolBinary_GlobEqual
                                          left: {(DQ ($ VSub_Name "$curPhase"))}
                                          right: {(fixupPhase)}
                                        )
                                      right: 
                                        (BoolUnary
                                          op_id: BoolUnary_n
                                          child: {(DQ ($ VSub_Name "$dontFixup"))}
                                        )
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Sentence
                              child: (ControlFlow token:<ControlFlow_Continue continue>)
                              terminator: <Op_Semi ";">
                            )
                          ]
                          spids: [-1 6155]
                        )
                      ]
                      spids: [-1 6160]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (LogicalAnd
                                      left: 
                                        (BoolBinary
                                          op_id: BoolBinary_GlobEqual
                                          left: {(DQ ($ VSub_Name "$curPhase"))}
                                          right: {(installCheckPhase)}
                                        )
                                      right: 
                                        (BoolUnary
                                          op_id: BoolUnary_z
                                          child: {(DQ ($ VSub_Name "$doInstallCheck"))}
                                        )
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Sentence
                              child: (ControlFlow token:<ControlFlow_Continue continue>)
                              terminator: <Op_Semi ";">
                            )
                          ]
                          spids: [-1 6186]
                        )
                      ]
                      spids: [-1 6191]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (LogicalAnd
                                      left: 
                                        (BoolBinary
                                          op_id: BoolBinary_GlobEqual
                                          left: {(DQ ($ VSub_Name "$curPhase"))}
                                          right: {(distPhase)}
                                        )
                                      right: 
                                        (BoolUnary
                                          op_id: BoolUnary_z
                                          child: {(DQ ($ VSub_Name "$doDist"))}
                                        )
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Sentence
                              child: (ControlFlow token:<ControlFlow_Continue continue>)
                              terminator: <Op_Semi ";">
                            )
                          ]
                          spids: [-1 6217]
                        )
                      ]
                      spids: [-1 6222]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (BoolUnary
                                      op_id: BoolUnary_n
                                      child: {(DQ ($ VSub_Name "$tracePhases"))}
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(echo)})
                            (C {(echo)} 
                              {
                                (DQ ("@ phase-started ") ($ VSub_Name "$out") (" ") 
                                  ($ VSub_Name "$curPhase")
                                )
                              }
                            )
                          ]
                          spids: [-1 6239]
                        )
                      ]
                      spids: [-1 6255]
                    )
                    (C {(showPhaseHeader)} {(DQ ($ VSub_Name "$curPhase"))})
                    (C {(dumpVars)})
                    (C {(eval)} 
                      {
                        (DQ 
                          (BracedVarSub
                            token: <VSub_Name curPhase>
                            prefix_op: VSub_Bang
                            suffix_op: 
                              (StringUnary
                                op_id: VTest_ColonHyphen
                                arg_word: {($ VSub_Name "$curPhase")}
                              )
                            spids: [6281 6286]
                          )
                        )
                      }
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$curPhase"))} {(Lit_Other "=")} 
                                  {(unpackPhase)} {(Lit_Other "]")}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(cd)} 
                              {
                                (DQ 
                                  (BracedVarSub
                                    token: <VSub_Name sourceRoot>
                                    suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(.)})
                                    spids: [6312 6316]
                                  )
                                )
                              }
                            )
                          ]
                          spids: [-1 6306]
                        )
                      ]
                      spids: [-1 6320]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-n)} {(DQ ($ VSub_Name "$tracePhases"))} 
                                  {(Lit_Other "]")}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(echo)})
                            (C {(echo)} 
                              {
                                (DQ ("@ phase-succeeded ") ($ VSub_Name "$out") (" ") 
                                  ($ VSub_Name "$curPhase")
                                )
                              }
                            )
                          ]
                          spids: [-1 6337]
                        )
                      ]
                      spids: [-1 6353]
                    )
                  ]
                  spids: [6036 6356]
                )
              spids: [6032 6034]
            )
          ]
          spids: [5920]
        )
      spids: [5916 5919]
    )
    (C {(runHook)} {(postHook)})
    (C {(runHook)} {(userHook)})
    (C {(dumpVars)})
  ]
)