(command.CommandList
  children: [
    (C {<Setup.require>} {<Config>})
    (C {<Setup.provide>} {<Haskell>} {<1.0>})
    (C {<Config.param>} {<'/haskell/packages'>} {<Id.Lit_Colon ':'>} {<a>} {<list>} {<of>} {<packages>} 
      {<to>} {<install>} {<from>} {<Hackage>}
    )
    (C {<Config.param>} {<'/haskell/base-packages'>} {<Id.Lit_Colon ':'>} {<a>} {<list>} {<of>} 
      {<already-installed>} {<packages>}
    )
    (C {<Config.param>} {<'/haskell/local-packages'>} {<Id.Lit_Colon ':'>} {<a>} {<list>} {<of>} {<package>} 
      {<source>} {<directories>}
    )
    (C {<Id.Lit_Colon ':'>} 
      {
        (braced_var_sub
          token: <Id.VSub_Name HS_PREFIX>
          suffix_op: 
            (suffix_op.Unary
              tok: <Id.VTest_Equals '='>
              arg_word: {<Id.Lit_Slash '/'> (${ Id.VSub_Name SETUP_PREFIX)}
            )
        )
      }
    )
    (C {<Id.Lit_Colon ':'>} 
      {
        (braced_var_sub
          token: <Id.VSub_Name HS_BUILD>
          suffix_op: 
            (suffix_op.Unary
              tok: <Id.VTest_Equals '='>
              arg_word: {(${ Id.VSub_Name HS_PREFIX) <.build> <Id.Lit_Slash '/'> <haskell>}
            )
        )
      }
    )
    (C {<Id.Lit_Colon ':'>} 
      {
        (braced_var_sub
          token: <Id.VSub_Name HS_ETC>
          suffix_op: 
            (suffix_op.Unary
              tok: <Id.VTest_Equals '='>
              arg_word: {(${ Id.VSub_Name HS_PREFIX) <etc>}
            )
        )
      }
    )
    (C {<Id.Lit_Colon ':'>} 
      {
        (braced_var_sub
          token: <Id.VSub_Name HS_BIN>
          suffix_op: 
            (suffix_op.Unary
              tok: <Id.VTest_Equals '='>
              arg_word: {(${ Id.VSub_Name HS_PREFIX) <.dist> <Id.Lit_Slash '/'> <bin>}
            )
        )
      }
    )
    (C {<Id.Lit_Colon ':'>} 
      {
        (braced_var_sub
          token: <Id.VSub_Name HS_SRC>
          suffix_op: 
            (suffix_op.Unary
              tok: <Id.VTest_Equals '='>
              arg_word: {(${ Id.VSub_Name HS_PREFIX) <src>}
            )
        )
      }
    )
    (C {<Id.Lit_Colon ':'>} 
      {
        (braced_var_sub
          token: <Id.VSub_Name HS_PKG>
          suffix_op: 
            (suffix_op.Unary
              tok: <Id.VTest_Equals '='>
              arg_word: {($ Id.VSub_DollarName '$HS_BUILD') <Id.Lit_Slash '/'> <package>}
            )
        )
      }
    )
    (C {<Id.Lit_Colon ':'>} 
      {
        (braced_var_sub
          token: <Id.VSub_Name HS_DEP>
          suffix_op: 
            (suffix_op.Unary
              tok: <Id.VTest_Equals '='>
              arg_word: {($ Id.VSub_DollarName '$HS_BUILD') <Id.Lit_Slash '/'> <deps>}
            )
        )
      }
    )
    (C {<Id.Lit_Colon ':'>} 
      {
        (braced_var_sub
          token: <Id.VSub_Name HS_CONF>
          suffix_op: 
            (suffix_op.Unary
              tok: <Id.VTest_Equals '='>
              arg_word: {($ Id.VSub_DollarName '$HS_BUILD') <Id.Lit_Slash '/'> <conf>}
            )
        )
      }
    )
    (C {<Id.Lit_Colon ':'>} 
      {
        (braced_var_sub
          token: <Id.VSub_Name HS_POOL>
          suffix_op: 
            (suffix_op.Unary
              tok: <Id.VTest_Equals '='>
              arg_word: {($ Id.VSub_DollarName '$HS_BUILD') <Id.Lit_Slash '/'> <pool>}
            )
        )
      }
    )
    (C {<Id.Lit_Colon ':'>} 
      {
        (braced_var_sub
          token: <Id.VSub_Name HS_OBJ>
          suffix_op: 
            (suffix_op.Unary
              tok: <Id.VTest_Equals '='>
              arg_word: {($ Id.VSub_DollarName '$HS_BUILD') <Id.Lit_Slash '/'> <obj>}
            )
        )
      }
    )
    (C {<Id.Lit_Colon ':'>} 
      {
        (braced_var_sub
          token: <Id.VSub_Name HS_LOG>
          suffix_op: 
            (suffix_op.Unary
              tok: <Id.VTest_Equals '='>
              arg_word: {($ Id.VSub_DollarName '$HS_BUILD') <Id.Lit_Slash '/'> <log>}
            )
        )
      }
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:GHC_VERSION)
          op: assign_op.Equal
          rhs: {(DQ (command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<ghc>} {<--version>})))}
          spids: [192]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:GHC_VERSION)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                (braced_var_sub
                  token: <Id.VSub_Name GHC_VERSION>
                  suffix_op: 
                    (suffix_op.Unary
                      tok: <Id.VOp1_Pound '#'>
                      arg_word: {<Id.Lit_Other '*'> <' version '>}
                    )
                )
              )
            }
          spids: [201]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:GHC_VNUM)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                (command_sub
                  left_token: <Id.Left_DollarParen '$('>
                  child: 
                    (command.CommandList
                      children: [
                        (command.Sentence
                          child: 
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:IFS)
                                  op: assign_op.Equal
                                  rhs: {<.>}
                                  spids: [214]
                                )
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:ver)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Id.Op_LParen _>
                                        words: [{($ Id.VSub_DollarName '$GHC_VERSION')}]
                                      )
                                    }
                                  spids: [217]
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                        (C {<printf>} {(DQ <'%d%02d'>)} 
                          {
                            (braced_var_sub
                              token: <Id.VSub_Name ver>
                              bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 0>})
                            )
                          } {(braced_var_sub token:<Id.VSub_Name ver> bracket_op:(bracket_op.ArrayIndex expr:{<Id.Lit_Digits 1>}))}
                        )
                      ]
                    )
                )
              )
            }
          spids: [211]
        )
      ]
    )
    (command.ShFunction
      name: Hackage.get
      body: 
        (BraceGroup
          children: [
            (C {<local>} 
              {<Id.Lit_VarLike 'pkg='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Number 2>
                    suffix_op: (suffix_op.Unary tok:<Id.VOp1_Pound '#'> arg_word:{<->})
                  )
                )
              }
            )
            (C {<mkpdir>} {(DQ ($ Id.VSub_Number '$1'))})
            (command.Simple
              words: [
                {<curl>}
                {<-Ls>}
                {<http> <Id.Lit_Colon ':'> <'//hackage.haskell.org/package/'> 
                  (DQ ($ Id.VSub_DollarName '$pkg')) <'/'> (DQ ($ Id.VSub_DollarName '$pkg')) <.tar.gz>
                }
              ]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_Number '$1'))}
                )
              ]
              do_fork: T
            )
          ]
        )
    )
    (command.ShFunction
      name: Tar.find
      body: 
        (BraceGroup
          children: [
            (C {<mkpdir>} {(DQ ($ Id.VSub_Number '$1'))})
            (command.Pipeline
              children: [
                (C {<tar>} {<-tzf>} {(DQ ($ Id.VSub_Number '$3'))})
                (command.Simple
                  words: [
                    {<grep>}
                    {<-e>}
                    {
                      (DQ 
                        (braced_var_sub
                          token: <Id.VSub_Number 2>
                          suffix_op: (suffix_op.Unary tok:<Id.VOp1_Pound '#'> arg_word:{<->})
                        )
                      )
                    }
                  ]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_Number '$1'))}
                    )
                  ]
                  do_fork: T
                )
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: Tar.get
      body: 
        (BraceGroup
          children: [
            (C {<mkpdir>} {(DQ ($ Id.VSub_Number '$1'))})
            (command.Simple
              words: [
                {<tar>}
                {<-xzOf>}
                {(DQ ($ Id.VSub_Number '$2'))}
                {
                  (DQ 
                    (command_sub
                      left_token: <Id.Left_DollarParen '$('>
                      child: 
                        (command.Simple
                          redirects: [
                            (redir
                              op: <Id.Redir_Less '<'>
                              loc: (redir_loc.Fd fd:0)
                              arg: {(DQ ($ Id.VSub_Number '$3'))}
                            )
                          ]
                          do_fork: F
                        )
                    )
                  )
                }
              ]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_Number '$1'))}
                )
              ]
              do_fork: T
            )
          ]
        )
    )
    (command.ShFunction
      name: Cabal.section
      body: 
        (BraceGroup
          children: [
            (C {<local>} 
              {<Id.Lit_VarLike 'field='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Number 2>
                    suffix_op: (suffix_op.Unary tok:<Id.VOp1_Pound '#'> arg_word:{<->})
                  )
                )
              }
            )
            (C {<mkpdir>} {(DQ ($ Id.VSub_Number '$1'))})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<local>} 
                  {<Id.Lit_VarLike 'text='> 
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C {<sed>} {<-rn>} 
                            {(SQ <'\n'> <'/^\\s*--/d\n'> <'/^library/I,/^\\S/{\n'> <'  /^\\s+'>) 
                              (DQ ($ Id.VSub_DollarName '$field')) (SQ <':/I{\n'> <'    :loop;{\n'> <'      /^\\s*--/{n;bloop}\n'> <'      /'>) 
                              (DQ ($ Id.VSub_DollarName '$field')) (SQ <':/Ibnext-line\n'> <'      /^\\S|:|\\bif\\b/bendloop\n'> <'      :next-line\n'> <'      s/'>) 
                              (DQ ($ Id.VSub_DollarName '$field')) (SQ <'://i;p;n\n'> <'      bloop\n'> <'    }\n'> <'    :endloop\t\n'> <'  }\n'> <'}\n'>)
                            } {(DQ ($ Id.VSub_Number '$3'))}
                          )
                      )
                    )
                  }
                )
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ ($ Id.VSub_Number '$4'))} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<local>} 
                      {<Id.Lit_VarLike 'IFS='> 
                        (DQ ($ Id.VSub_DollarName '$IFS') 
                          (braced_var_sub
                            token: <Id.VSub_Number 4>
                            suffix_op: (suffix_op.Unary tok:<Id.VOp1_Pound '#'> arg_word:{<->})
                          )
                        )
                      }
                    )
                  ]
                  spids: [474 487]
                )
              ]
            )
            (command.Simple
              words: [
                {<printf>}
                {(DQ <'%s'> <Id.Lit_BadBackslash '\\'> <n>)}
                {($ Id.VSub_DollarName '$text')}
              ]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_Number '$1'))}
                )
              ]
              do_fork: T
            )
          ]
        )
    )
    (command.ShFunction
      name: HS.GHCAutoConf
      body: 
        (BraceGroup
          children: [
            (command.Simple
              words: [{<cat>}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_Number '$1') <.c>)}
                )
                (redir
                  op: <Id.Redir_DLess '<<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: 
                    (redir_param.HereDoc
                      here_begin: {<EOF>}
                      here_end_span_id: 769
                      stdin_parts: [
                        <'#include <stdio.h>\n'>
                        <'#include <stdint.h>\n'>
                        <'\n'>
                        <'int main() {\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define SIZEOF_WORD32      %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(uint32_t));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define ALIGNMENT_WORD32   %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(uint32_t));\n'>
                        <'\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define SIZEOF_INT8_T     %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(int8_t));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define ALIGNMENT_INT8_T  %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(int8_t));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define SIZEOF_INT16_T    %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(int16_t));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define ALIGNMENT_INT16_T %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(int16_t));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define SIZEOF_INT32_T    %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(int32_t));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define ALIGNMENT_INT32_T %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(int32_t));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define SIZEOF_INT64_T    %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(int64_t));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define ALIGNMENT_INT64_T %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(int64_t));\n'>
                        <'\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define SIZEOF_UINT8_T     %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(uint8_t));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define ALIGNMENT_UINT8_T  %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(uint8_t));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define SIZEOF_UINT16_T    %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(uint16_t));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define ALIGNMENT_UINT16_T %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(uint16_t));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define SIZEOF_UINT32_T    %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(uint32_t));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define ALIGNMENT_UINT32_T %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(uint32_t));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define SIZEOF_UINT64_T    %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(uint64_t));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define ALIGNMENT_UINT64_T %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(uint64_t));\n'>
                        <'\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define SIZEOF_VOID_P      %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(void*));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define ALIGNMENT_VOID_P   %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(void*));\n'>
                        <'\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define SIZEOF_FLOAT       %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(float));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define ALIGNMENT_FLOAT    %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(float));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define SIZEOF_DOUBLE      %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(double));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define ALIGNMENT_DOUBLE   %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(double));\n'>
                        <'\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define SIZEOF_INT        %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(int));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define ALIGNMENT_INT     %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(int));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define SIZEOF_LONG       %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(long));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define ALIGNMENT_LONG    %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(long));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define SIZEOF_LONG_LONG       %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(long long));\n'>
                        <'    printf('>
                        <Id.Right_DoubleQuote '"'>
                        <'#define ALIGNMENT_LONG_LONG    %d'>
                        <Id.Lit_BadBackslash '\\'>
                        <n>
                        <Id.Right_DoubleQuote '"'>
                        <',sizeof(long long));\n'>
                        <'\n'>
                        <'    return 0;\n'>
                        <'}\n'>
                      ]
                    )
                )
              ]
              do_fork: T
            )
            (C {<gcc>} {(DQ ($ Id.VSub_Number '$1') <.c>)} {<-o>} {(DQ ($ Id.VSub_Number '$1') <.x>)})
            (C {<rm>} {<-f>} {(DQ ($ Id.VSub_Number '$1') <.c>)})
            (command.Simple
              words: [{(DQ ($ Id.VSub_Number '$1') <.x>)}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_Number '$1'))}
                )
              ]
              do_fork: T
            )
            (C {<rm>} {<-f>} {(DQ ($ Id.VSub_Number '$1') <.x>)})
          ]
        )
    )
    (command.ShFunction
      name: HS.MachDeps
      body: 
        (BraceGroup
          children: [
            (C {<mkpdir>} {(DQ ($ Id.VSub_Number '$1'))})
            (command.Simple
              words: [{<cat>}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_Number '$1'))}
                )
                (redir
                  op: <Id.Redir_DLess '<<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: 
                    (redir_param.HereDoc
                      here_begin: {<EOF>}
                      here_end_span_id: 975
                      stdin_parts: [
                        <
'/* -----------------------------------------------------------------------------\n'
                        >
                        <' *\n'>
                        <' * (c) The University of Glasgow 2002\n'>
                        <' *\n'>
                        <' * Definitions that characterise machine specific properties of basic\n'>
                        <' * types (C & Haskell) of a target platform.\n'>
                        <' *\n'>
                        <' * NB: Keep in sync with HsFFI.h and StgTypes.h.\n'>
                        <' * NB: THIS FILE IS INCLUDED IN HASKELL SOURCE!\n'>
                        <' *\n'>
                        <' * To understand the structure of the RTS headers, see the wiki:\n'>
                        <
' *   http://ghc.haskell.org/trac/ghc/wiki/Commentary/SourceTree/Includes\n'
                        >
                        <' *\n'>
                        <
' * ---------------------------------------------------------------------------*/\n'
                        >
                        <'\n'>
                        <'#pragma once\n'>
                        <'\n'>
                        <'/* Don\'t allow stage1 (cross-)compiler embed assumptions about target\n'>
                        <
' * platform. When ghc-stage1 is being built by ghc-stage0 is should not\n'
                        >
                        <' * refer to target defines. A few past examples:\n'>
                        <' *  - https://ghc.haskell.org/trac/ghc/ticket/13491\n'>
                        <' *  - https://phabricator.haskell.org/D3122\n'>
                        <' *  - https://phabricator.haskell.org/D3405\n'>
                        <' *\n'>
                        <' * In those cases code change assumed target defines like SIZEOF_HSINT\n'>
                        <' * are applied to host platform, not target platform.\n'>
                        <' *\n'>
                        <' * So what should be used instead in STAGE=1?\n'>
                        <' *\n'>
                        <
' * To get host\'s equivalent of SIZEOF_HSINT you can use Bits instances:\n'
                        >
                        <' *    Data.Bits.finiteBitSize (0 :: Int)\n'>
                        <' *\n'>
                        <' * To get target\'s values it is preferred to use runtime target\n'>
                        <' * configuration from \'targetPlatform :: DynFlags -> Platform\'\n'>
                        <' * record. A few wrappers are already defined and used throughout GHC:\n'>
                        <' *    wORD_SIZE :: DynFlags -> Int\n'>
                        <
' *    wORD_SIZE dflags = pc_WORD_SIZE (sPlatformConstants (settings dflags))\n'
                        >
                        <' *\n'>
                        <' * Hence we hide these macros from -DSTAGE=1\n'>
                        <' */\n'>
                        <'#if !defined(STAGE) || STAGE >= 2\n'>
                        <'\n'>
                        <'/* Sizes of C types come from here... */\n'>
                        <'#include '>
                        <Id.Right_DoubleQuote '"'>
                        <ghcautoconf.h>
                        <Id.Right_DoubleQuote '"'>
                        <'\n'>
                        <'\n'>
                        <'/* Sizes of Haskell types follow.  These sizes correspond to:\n'>
                        <' *   - the number of bytes in the primitive type (eg. Int#)\n'>
                        <' *   - the number of bytes in the external representation (eg. HsInt)\n'>
                        <' *   - the scale offset used by writeFooOffAddr#\n'>
                        <' *\n'>
                        <' * In the heap, the type may take up more space: eg. SIZEOF_INT8 == 1,\n'>
                        <' * but it takes up SIZEOF_HSWORD (4 or 8) bytes in the heap.\n'>
                        <' */\n'>
                        <'\n'>
                        <'#define SIZEOF_HSCHAR           SIZEOF_WORD32\n'>
                        <'#define ALIGNMENT_HSCHAR        ALIGNMENT_WORD32\n'>
                        <'\n'>
                        <'#define SIZEOF_HSINT            SIZEOF_VOID_P\n'>
                        <'#define ALIGNMENT_HSINT         ALIGNMENT_VOID_P\n'>
                        <'\n'>
                        <'#define SIZEOF_HSWORD           SIZEOF_VOID_P\n'>
                        <'#define ALIGNMENT_HSWORD        ALIGNMENT_VOID_P\n'>
                        <'\n'>
                        <'#define SIZEOF_HSDOUBLE         SIZEOF_DOUBLE\n'>
                        <'#define ALIGNMENT_HSDOUBLE      ALIGNMENT_DOUBLE\n'>
                        <'\n'>
                        <'#define SIZEOF_HSFLOAT          SIZEOF_FLOAT\n'>
                        <'#define ALIGNMENT_HSFLOAT       ALIGNMENT_FLOAT\n'>
                        <'\n'>
                        <'#define SIZEOF_HSPTR            SIZEOF_VOID_P\n'>
                        <'#define ALIGNMENT_HSPTR         ALIGNMENT_VOID_P\n'>
                        <'\n'>
                        <'#define SIZEOF_HSFUNPTR         SIZEOF_VOID_P\n'>
                        <'#define ALIGNMENT_HSFUNPTR      ALIGNMENT_VOID_P\n'>
                        <'\n'>
                        <'#define SIZEOF_HSSTABLEPTR      SIZEOF_VOID_P\n'>
                        <'#define ALIGNMENT_HSSTABLEPTR   ALIGNMENT_VOID_P\n'>
                        <'\n'>
                        <'#define SIZEOF_INT8             SIZEOF_INT8_T\n'>
                        <'#define ALIGNMENT_INT8          ALIGNMENT_INT8_T\n'>
                        <'\n'>
                        <'#define SIZEOF_WORD8            SIZEOF_UINT8_T\n'>
                        <'#define ALIGNMENT_WORD8         ALIGNMENT_UINT8_T\n'>
                        <'\n'>
                        <'#define SIZEOF_INT16            SIZEOF_INT16_T\n'>
                        <'#define ALIGNMENT_INT16         ALIGNMENT_INT16_T\n'>
                        <'\n'>
                        <'#define SIZEOF_WORD16           SIZEOF_UINT16_T\n'>
                        <'#define ALIGNMENT_WORD16        ALIGNMENT_UINT16_T\n'>
                        <'\n'>
                        <'#define SIZEOF_INT32            SIZEOF_INT32_T\n'>
                        <'#define ALIGNMENT_INT32         ALIGNMENT_INT32_T\n'>
                        <'\n'>
                        <'#define SIZEOF_WORD32           SIZEOF_UINT32_T\n'>
                        <'#define ALIGNMENT_WORD32        ALIGNMENT_UINT32_T\n'>
                        <'\n'>
                        <'#define SIZEOF_INT64            SIZEOF_INT64_T\n'>
                        <'#define ALIGNMENT_INT64         ALIGNMENT_INT64_T\n'>
                        <'\n'>
                        <'#define SIZEOF_WORD64           SIZEOF_UINT64_T\n'>
                        <'#define ALIGNMENT_WORD64        ALIGNMENT_UINT64_T\n'>
                        <'\n'>
                        <'#if !defined(WORD_SIZE_IN_BITS)\n'>
                        <'#if SIZEOF_HSWORD == 4\n'>
                        <'#define WORD_SIZE_IN_BITS       32\n'>
                        <'#define WORD_SIZE_IN_BITS_FLOAT 32.0\n'>
                        <'#else\n'>
                        <'#define WORD_SIZE_IN_BITS       64\n'>
                        <'#define WORD_SIZE_IN_BITS_FLOAT 64.0\n'>
                        <'#endif\n'>
                        <'#endif\n'>
                        <'\n'>
                        <'#if !defined(TAG_BITS)\n'>
                        <'#if SIZEOF_HSWORD == 4\n'>
                        <'#define TAG_BITS                2\n'>
                        <'#else\n'>
                        <'#define TAG_BITS                3\n'>
                        <'#endif\n'>
                        <'#endif\n'>
                        <'\n'>
                        <'#define TAG_MASK ((1 << TAG_BITS) - 1)\n'>
                        <'\n'>
                        <'#endif /* !defined(STAGE) || STAGE >= 2 */\n'>
                        <'\n'>
                      ]
                    )
                )
              ]
              do_fork: T
            )
          ]
        )
    )
    (command.ShFunction
      name: HS.StdHeader
      body: 
        (BraceGroup
          children: [
            (C {<mkpdir>} {(DQ ($ Id.VSub_Number '$1'))})
            (C {<shopt>} {<-s>} {<globstar>})
            (C {<cp>} 
              {(DQ <'/usr/lib/ghc-'> ($ Id.VSub_DollarName '$GHC_VERSION') <'/'>) <Id.Lit_Star '*'> 
                <Id.Lit_Star '*'> (DQ <'/include/'>) <Id.Lit_Star '*'> <Id.Lit_Star '*'> 
                (DQ <'/'> 
                  (braced_var_sub
                    token: <Id.VSub_Number 2>
                    suffix_op: (suffix_op.Unary tok:<Id.VOp1_Pound '#'> arg_word:{<->})
                  ) <.h>
                )
              } {(DQ ($ Id.VSub_Number '$1'))}
            )
          ]
        )
    )
    (command.ShFunction
      name: HS.pp
      body: 
        (BraceGroup
          children: [
            (C {<mkpdir>} {(DQ ($ Id.VSub_Number '$1'))})
            (command.Simple
              words: [
                {<cpp>}
                {<-traditional-cpp>}
                {<-undef>}
                {<-DWORLD_IMPORTS>}
                {<-I> (DQ ($ Id.VSub_DollarName '$SETUP_ROOT') ($ Id.VSub_DollarName '$HS_POOL'))}
                {<-w>}
                {<-include>}
                {(DQ ($ Id.VSub_Number '$3'))}
                {(DQ ($ Id.VSub_Number '$2'))}
              ]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_Number '$1'))}
                )
              ]
              do_fork: T
            )
          ]
        )
    )
    (command.ShFunction
      name: HS.cc
      body: 
        (BraceGroup
          children: [
            (C {<mkpdir>} {(DQ ($ Id.VSub_Number '$1'))})
            (C {<ghc>} {<-c>} 
              {<-I> (DQ ($ Id.VSub_DollarName '$SETUP_ROOT') ($ Id.VSub_DollarName '$HS_POOL'))} {(DQ ($ Id.VSub_Number '$2'))} {<-o>} {(DQ ($ Id.VSub_Number '$1'))}
            )
          ]
        )
    )
    (command.ShFunction
      name: HS.depends
      body: 
        (BraceGroup
          children: [
            (C {<mkpdir>} {(DQ ($ Id.VSub_Number '$1'))})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.Pipeline
                  children: [
                    (C {<sed>} {<-rn>} 
                      {
                        (SQ 
                          <
'/\\{-/{:loop;/-\\}/!{N;bloop}};s/\\{-.*-\\}//;s/^import(\\s+qualified)?\\s+([A-Z][A-Za-z0-9_.]*).*$/\\2/p'
                          >
                        )
                      } {(DQ ($ Id.VSub_Number '$2'))}
                    )
                    (command.Simple
                      words: [{<grep>} {<-vxf>} {(DQ ($ Id.VSub_Number '$3'))}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_Number '$1'))}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  negated: F
                )
                (C {<Id.Lit_Colon ':'>})
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: Choose
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: 
                (C 
                  {
                    (DQ 
                      (braced_var_sub
                        token: <Id.VSub_Number 2>
                        suffix_op: (suffix_op.Unary tok:<Id.VOp1_Pound '#'> arg_word:{<->})
                      )
                    )
                  } {(DQ ($ Id.VSub_Number '$1'))} 
                  {
                    (DQ 
                      (braced_var_sub
                        token: <Id.VSub_At '@'>
                        suffix_op: (suffix_op.Slice begin:{<Id.Lit_Digits 3>})
                      )
                    )
                  }
                )
              terminator: <Id.Op_Semi _>
            )
          ]
        )
    )
    (command.ShFunction
      name: HS.get.args
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: (C {<local>} {<Id.Lit_VarLike 'dst='> (DQ ($ Id.VSub_Number '$1'))})
              terminator: <Id.Op_Semi _>
            )
            (C {<shift>})
            (C {<local>} 
              {<Id.Lit_VarLike 'mod='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Number 1>
                    suffix_op: (suffix_op.Unary tok:<Id.VOp1_Pound '#'> arg_word:{<->})
                  )
                )
              } 
              {<Id.Lit_VarLike 'pkg='> 
                (DQ 
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (command.Simple
                        redirects: [
                          (redir
                            op: <Id.Redir_Less '<'>
                            loc: (redir_loc.Fd fd:0)
                            arg: {(DQ ($ Id.VSub_Number '$2'))}
                          )
                        ]
                        do_fork: F
                      )
                  )
                )
              } 
              {<Id.Lit_VarLike 'name='> 
                (DQ 
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (command.Simple
                        redirects: [
                          (redir
                            op: <Id.Redir_Less '<'>
                            loc: (redir_loc.Fd fd:0)
                            arg: {(DQ ($ Id.VSub_Number '$3'))}
                          )
                        ]
                        do_fork: F
                      )
                  )
                )
              }
            )
            (C {<mkpdir>} {(DQ ($ Id.VSub_DollarName '$dst'))})
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$name'))}
              arms: [
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'> <.hsc>}]
                  action: [
                    (C {<printf>} {(DQ <'%s %s'> <Id.Lit_BadBackslash '\\'> <n>)} {<-Copy>} 
                      {
                        (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> ($ Id.VSub_DollarName '$mod') 
                          <.hsc_hs>
                        )
                      }
                    )
                  ]
                  spids: [1270 1272 1292 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'> <.hs>}]
                  action: [
                    (C {<printf>} {(DQ <'%s %s %s'> <Id.Lit_BadBackslash '\\'> <n>)} {<-Tar.get>} 
                      {(DQ ($ Id.VSub_DollarName '$pkg'))} {(DQ <'/'> ($ Id.VSub_Number '$3'))}
                    )
                  ]
                  spids: [1295 1297 1317 -1]
                )
              ]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_DollarName '$dst'))}
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: HS.hsc
      body: 
        (BraceGroup
          children: [
            (C {<mkpdir>} {(DQ ($ Id.VSub_Number '$1'))})
            (C {<hsc2hs>} {<-o>} {(DQ ($ Id.VSub_Number '$1'))} 
              {<-I> (DQ ($ Id.VSub_DollarName '$SETUP_ROOT') ($ Id.VSub_DollarName '$HS_POOL'))} {<-D_GNU_SOURCE>} {<-DWORLD_IMPORTS>} 
              {<-i> (DQ ($ Id.VSub_DollarName '$SETUP_ROOT') <'/'> ($ Id.VSub_Number '$3'))} {(DQ ($ Id.VSub_Number '$2'))}
            )
          ]
        )
    )
    (command.ShFunction
      name: HS.pkgMods
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<pkg>})
            (C {<mkpdir>} {(DQ ($ Id.VSub_Number '$1'))})
            (command.Pipeline
              children: [
                (command.ForEach
                  iter_name: pkg
                  iter_words: [
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Simple
                            redirects: [
                              (redir
                                op: <Id.Redir_Less '<'>
                                loc: (redir_loc.Fd fd:0)
                                arg: {(DQ ($ Id.VSub_Number '$2'))}
                              )
                            ]
                            do_fork: F
                          )
                      )
                    }
                  ]
                  do_arg_iter: F
                  body: 
                    (command.DoGroup
                      children: [
                        (C {<printf>} {(DQ <'%s'> <Id.Lit_BadBackslash '\\'> <n>)} 
                          {
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              child: 
                                (C {<ghc-pkg>} {<field>} {(DQ ($ Id.VSub_DollarName '$pkg'))} 
                                  {<exposed-modules>}
                                )
                            )
                          }
                        )
                      ]
                    )
                )
                (command.Simple
                  words: [{<sort>} {<-u>}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_Number '$1'))}
                    )
                  ]
                  do_fork: T
                )
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: HS.compile
      body: 
        (BraceGroup
          children: [
            (C {<mkpdir>} {(DQ ($ Id.VSub_Number '$1'))} {(DQ ($ Id.VSub_Number '$2'))})
            (C {<ghc>} {<-optP>} {<--include> <Id.Lit_Equals '='> (DQ ($ Id.VSub_Number '$4'))} {<-o>} 
              {(DQ ($ Id.VSub_Number '$1'))} {<-ohi>} {(DQ ($ Id.VSub_Number '$2'))} 
              {<-I> (DQ ($ Id.VSub_DollarName '$SETUP_ROOT') ($ Id.VSub_DollarName '$HS_POOL'))} {<-i> (DQ ($ Id.VSub_DollarName '$SETUP_ROOT') ($ Id.VSub_DollarName '$HS_OBJ'))} {<-c>} 
              {
                (braced_var_sub
                  token: <Id.VSub_Number 5>
                  suffix_op: 
                    (suffix_op.Unary
                      tok: <Id.VTest_ColonPlus ':+'>
                      arg_word: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (command.Simple
                                redirects: [
                                  (redir
                                    op: <Id.Redir_Less '<'>
                                    loc: (redir_loc.Fd fd:0)
                                    arg: {(DQ ($ Id.VSub_Number '$5'))}
                                  )
                                ]
                                do_fork: F
                              )
                          )
                        }
                    )
                )
              } {(DQ ($ Id.VSub_Number '$3'))}
            )
          ]
        )
    )
    (command.ShFunction
      name: HS.ld
      body: 
        (BraceGroup
          children: [
            (C {<mkpdir>} {(DQ ($ Id.VSub_Number '$1'))})
            (C {<local>} {<-a>} 
              {<Id.Lit_VarLike 'pkgs='> 
                (sh_array_literal
                  left: <Id.Op_LParen _>
                  words: [
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Simple
                            redirects: [
                              (redir
                                op: <Id.Redir_Less '<'>
                                loc: (redir_loc.Fd fd:0)
                                arg: {(DQ ($ Id.VSub_Number '$2'))}
                              )
                            ]
                            do_fork: F
                          )
                      )
                    }
                  ]
                )
              }
            )
            (C {<local>} {<-a>} 
              {<Id.Lit_VarLike 'opts='> 
                (sh_array_literal
                  left: <Id.Op_LParen _>
                  words: [
                    {<-hide-all-packages>}
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name pkgs>
                        bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                        suffix_op: 
                          (suffix_op.PatSub
                            pat: {}
                            replace: {<'-package '>}
                            replace_mode: Id.Lit_Pound
                          )
                      )
                    }
                  ]
                )
              }
            )
            (C {<echo>} {<ghc>} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name opts>
                    bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                  )
                )
              } {<-o>} {(DQ ($ Id.VSub_Number '$1'))} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_At '@'>
                    suffix_op: (suffix_op.Slice begin:{<Id.Lit_Digits 3>})
                  )
                )
              }
            )
            (C {<ghc>} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name opts>
                    bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                  )
                )
              } {<-o>} {(DQ ($ Id.VSub_Number '$1'))} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_At '@'>
                    suffix_op: (suffix_op.Slice begin:{<Id.Lit_Digits 3>})
                  )
                )
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: HS.fullPkgs
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<pkg>} {<vers>})
            (C {<mkpdir>} {(DQ ($ Id.VSub_Number '$1'))})
            (command.ForEach
              iter_name: pkg
              iter_words: [
                {
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (command.Simple
                        redirects: [
                          (redir
                            op: <Id.Redir_Less '<'>
                            loc: (redir_loc.Fd fd:0)
                            arg: {(DQ ($ Id.VSub_Number '$2'))}
                          )
                        ]
                        do_fork: F
                      )
                  )
                }
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:vers)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (command_sub
                                  left_token: <Id.Left_DollarParen '$('>
                                  child: 
                                    (C {<ghc-pkg>} {<field>} {(DQ ($ Id.VSub_DollarName '$pkg'))} 
                                      {<version>}
                                    )
                                )
                              )
                            }
                          spids: [1682]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:vers)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name vers>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      tok: <Id.VOp1_Pound '#'>
                                      arg_word: {<'version: '>}
                                    )
                                )
                              )
                            }
                          spids: [1698]
                        )
                      ]
                    )
                    (C {<printf>} {(DQ <'%s'> <Id.Lit_BadBackslash '\\'> <n>)} 
                      {(DQ ($ Id.VSub_DollarName '$pkg') <-> ($ Id.VSub_DollarName '$vers'))}
                    )
                  ]
                )
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_Number '$1'))}
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: HS.macros.genPkg
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: (C {<local>} {<pName>} {<vers>} {<a>} {<b>} {<c>})
              terminator: <Id.Op_Semi _>
            )
            (C {<local>} {<-a>} {<vns>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:pName)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (braced_var_sub
                          token: <Id.VSub_Number 1>
                          suffix_op: 
                            (suffix_op.Unary
                              tok: <Id.VOp1_Percent '%'>
                              arg_word: {<-> <Id.Lit_Other '*'>}
                            )
                        )
                      )
                    }
                  spids: [1762]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:pName)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (braced_var_sub
                          token: <Id.VSub_Name pName>
                          suffix_op: 
                            (suffix_op.PatSub
                              pat: {<->}
                              replace: {<_>}
                              replace_mode: Id.Lit_Slash
                            )
                        )
                      )
                    }
                  spids: [1773]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:vers)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (braced_var_sub
                          token: <Id.VSub_Number 1>
                          suffix_op: 
                            (suffix_op.Unary
                              tok: <Id.VOp1_DPound '##'>
                              arg_word: {<Id.Lit_Other '*'> <->}
                            )
                        )
                      )
                    }
                  spids: [1786]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:vns)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (sh_array_literal
                        left: <Id.Op_LParen _>
                        words: [
                          {
                            (braced_var_sub
                              token: <Id.VSub_Name vers>
                              suffix_op: 
                                (suffix_op.PatSub
                                  pat: {<.>}
                                  replace: {<' '>}
                                  replace_mode: Id.Lit_Slash
                                )
                            )
                          }
                          {<0>}
                          {<0>}
                        ]
                      )
                    }
                  spids: [1797]
                )
              ]
            )
            (command.Sentence
              child: 
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:a)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ 
                            (braced_var_sub
                              token: <Id.VSub_Name vns>
                              bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 0>})
                            )
                          )
                        }
                      spids: [1816]
                    )
                  ]
                )
              terminator: <Id.Op_Semi _>
            )
            (command.Sentence
              child: 
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:b)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ 
                            (braced_var_sub
                              token: <Id.VSub_Name vns>
                              bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 1>})
                            )
                          )
                        }
                      spids: [1828]
                    )
                  ]
                )
              terminator: <Id.Op_Semi _>
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:c)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (braced_var_sub
                          token: <Id.VSub_Name vns>
                          bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 2>})
                        )
                      )
                    }
                  spids: [1840]
                )
              ]
            )
            (command.Simple
              words: [{<cat>}]
              redirects: [
                (redir
                  op: <Id.Redir_DLess '<<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: 
                    (redir_param.HereDoc
                      here_begin: {<EOF>}
                      here_end_span_id: 1882
                      stdin_parts: [
                        <'#define VERSION_'>
                        ($ Id.VSub_DollarName '$pName')
                        <' '>
                        <Id.Right_DoubleQuote '"'>
                        ($ Id.VSub_DollarName '$vers')
                        <Id.Right_DoubleQuote '"'>
                        <'\n'>
                        <'#undef MIN_VERSION_'>
                        ($ Id.VSub_DollarName '$pName')
                        <'\n'>
                        <'#define MIN_VERSION_'>
                        ($ Id.VSub_DollarName '$pName')
                        <'(maj1,maj2,min) ( maj1 < '>
                        ($ Id.VSub_DollarName '$a')
                        <' || (maj1) == '>
                        ($ Id.VSub_DollarName '$a')
                        <' && (maj2) < '>
                        ($ Id.VSub_DollarName '$b')
                        <' || (maj1) == '>
                        ($ Id.VSub_DollarName '$a')
                        <' && (maj2) == '>
                        ($ Id.VSub_DollarName '$b')
                        <' && (min) <= '>
                        ($ Id.VSub_DollarName '$c')
                        <' )\n'>
                      ]
                    )
                )
              ]
              do_fork: T
            )
          ]
        )
    )
    (command.ShFunction
      name: HS.macros
      body: 
        (BraceGroup
          children: [
            (C {<echo>} {<HS.macros>} {(DQ ($ Id.VSub_At '$@'))})
            (C {<local>} {<-a>} 
              {<Id.Lit_VarLike 'packages='> 
                (sh_array_literal
                  left: <Id.Op_LParen _>
                  words: [
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Simple
                            redirects: [
                              (redir
                                op: <Id.Redir_Less '<'>
                                loc: (redir_loc.Fd fd:0)
                                arg: {(DQ ($ Id.VSub_Number '$2'))}
                              )
                            ]
                            do_fork: F
                          )
                      )
                    }
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Simple
                            redirects: [
                              (redir
                                op: <Id.Redir_Less '<'>
                                loc: (redir_loc.Fd fd:0)
                                arg: {(DQ ($ Id.VSub_Number '$3'))}
                              )
                            ]
                            do_fork: F
                          )
                      )
                    }
                  ]
                )
              } 
              {<Id.Lit_VarLike 'core_packages='> 
                (sh_array_literal
                  left: <Id.Op_LParen _>
                  words: [
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Simple
                            redirects: [
                              (redir
                                op: <Id.Redir_Less '<'>
                                loc: (redir_loc.Fd fd:0)
                                arg: {(DQ ($ Id.VSub_Number '$4'))}
                              )
                            ]
                            do_fork: F
                          )
                      )
                    }
                  ]
                )
              }
            )
            (C {<mkpdir>} {(DQ ($ Id.VSub_Number '$1'))})
            (BraceGroup
              children: [
                (command.Simple
                  words: [{<cat>}]
                  redirects: [
                    (redir
                      op: <Id.Redir_DLess '<<'>
                      loc: (redir_loc.Fd fd:0)
                      arg: 
                        (redir_param.HereDoc
                          here_begin: {<EOF>}
                          here_end_span_id: 1978
                          stdin_parts: [
                            <'#ifndef __GLASGOW_HASKELL__\n'>
                            <'#define __GLASGOW_HASKELL__ '>
                            ($ Id.VSub_DollarName '$GHC_VNUM')
                            <'\n'>
                            <'#endif\n'>
                            <'#define HASH_TOK #\n'>
                            <'#define CALLCONV ccall\n'>
                            <'#define USE_DLSYM 1\n'>
                            <'#define IS_WINDOWS False\n'>
                            <'#define DATA_DIR '>
                            <Id.Right_DoubleQuote '"'>
                            ($ Id.VSub_DollarName '$INSTALL')
                            <'/share/world'>
                            <Id.Right_DoubleQuote '"'>
                            <'\n'>
                            <'#define EXE_EXTENSION '>
                            <Id.Right_DoubleQuote '"'>
                            <Id.Right_DoubleQuote '"'>
                            <'\n'>
                            <'#define _FILE_OFFSET_BITS 64\n'>
                          ]
                        )
                    )
                  ]
                  do_fork: T
                )
                (command.ForEach
                  iter_name: p
                  iter_words: [
                    {
                      (DQ 
                        (braced_var_sub
                          token: <Id.VSub_Name packages>
                          bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                        )
                      )
                    }
                  ]
                  do_arg_iter: F
                  body: 
                    (command.DoGroup
                      children: [
                        (command.Sentence
                          child: (C {<HS.macros.genPkg>} {(DQ ($ Id.VSub_DollarName '$p'))})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                )
                (C {<echo>} {(DQ <'#if __GLASGOW_HASKELL__ < 800 || defined(WORLD_IMPORTS)'>)})
                (command.ForEach
                  iter_name: p
                  iter_words: [
                    {
                      (DQ 
                        (braced_var_sub
                          token: <Id.VSub_Name core_packages>
                          bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                        )
                      )
                    }
                  ]
                  do_arg_iter: F
                  body: 
                    (command.DoGroup
                      children: [
                        (command.Sentence
                          child: (C {<HS.macros.genPkg>} {(DQ ($ Id.VSub_DollarName '$p'))})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                )
                (C {<echo>} {(DQ <'#endif'>)})
              ]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_Number '$1'))}
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: HS.includes
      body: 
        (BraceGroup
          children: [
            (C {<mkpdir>} {(DQ ($ Id.VSub_Number '$1'))})
            (command.Pipeline
              children: [
                (C {<sed>} {<-rn>} 
                  {(SQ <'s,^\\s*#\\s*include\\s*("(.*\\.hs?)"|<(Hs.*\\.h)>)\\s*$,\\2\\3,p'>)} {(DQ ($ Id.VSub_Number '$2'))}
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ ($ Id.VSub_Number '$3'))} 
                                  {<Id.Lit_RBracket ']'>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      action: [
                        (command.Sentence
                          child: 
                            (C {<grep>} {<-v>} 
                              {
                                (DQ 
                                  (braced_var_sub
                                    token: <Id.VSub_Number 3>
                                    suffix_op: (suffix_op.Unary tok:<Id.VOp1_Pound '#'> arg_word:{<->})
                                  )
                                )
                              }
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                      spids: [2092 2105]
                    )
                  ]
                  else_action: [(command.Sentence child:(C {<cat>}) terminator:<Id.Op_Semi _>)]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_Number '$1'))}
                    )
                  ]
                )
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: HS.isLocalMod
      body: 
        (BraceGroup
          children: [
            (C {<local>} 
              {<Id.Lit_VarLike 'modpath='> 
                (sh_array_literal
                  left: <Id.Op_LParen _>
                  words: [
                    {(DQ ($ Id.VSub_DollarName '$SETUP_ROOT') ($ Id.VSub_DollarName '$HS_SRC') <'/'>) 
                      <Id.Lit_Star '*'> <'/'> <Id.Lit_Star '*'> (DQ <'/source/'> ($ Id.VSub_Number '$1') <.>) 
                      (braced_var_sub
                        token: <Id.VSub_Number 2>
                        suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:{<hs>})
                      )
                    }
                  ]
                )
              }
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {<-e>} {(DQ ($ Id.VSub_DollarName '$modpath'))} 
                  {<Id.Lit_RBracket ']'>}
                )
                (BraceGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:modpath)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name modpath>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      tok: <Id.VOp1_Pound '#'>
                                      arg_word: 
                                        {($ Id.VSub_DollarName '$SETUP_ROOT') 
                                          ($ Id.VSub_DollarName '$HS_SRC') <Id.Lit_Slash '/'>
                                        }
                                    )
                                )
                              )
                            }
                          spids: [2187]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:HS_MOD_PATH)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name modpath>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      tok: <Id.VOp1_Percent '%'>
                                      arg_word: 
                                        {<Id.Lit_Slash '/'> <source> <Id.Lit_Slash '/'> 
                                          <Id.Lit_Other '*'>
                                        }
                                    )
                                )
                              )
                            }
                          spids: [2199]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: HS.source-dir
      body: 
        (BraceGroup
          children: [
            (C {<shopt>} {<-s>} {<globstar>})
            (C {<local>} {<src>} {<obj>} {<Id.Lit_VarLike 'srcdir='> (DQ ($ Id.VSub_Number '$2'))} 
              {<Id.Lit_VarLike 'etcdir='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Number 3>
                    suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:{<etc>})
                  )
                )
              }
            )
            (C {<Setup.use>} {<Pkg>})
            (C {<Pkg.name>} {<'haskell/'> (DQ ($ Id.VSub_Number '$1'))})
            (C {<prepare>} 
              {(DQ ($ Id.VSub_DollarName '$HS_PKG') <'/'> ($ Id.VSub_Number '$1') <'/c-sources'>)} {<Id.Lit_Equals '='>} {<Empty>}
            )
            (command.ForEach
              iter_name: src
              iter_words: [
                {(DQ ($ Id.VSub_DollarName '$srcdir')) <'/'> <Id.Lit_Star '*'> <Id.Lit_Star '*'> <'/'> 
                  <Id.Lit_Star '*'> <.hs>
                }
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:src)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name src>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      tok: <Id.VOp1_Pound '#'>
                                      arg_word: {($ Id.VSub_DollarName '$srcdir') <Id.Lit_Slash '/'>}
                                    )
                                )
                              )
                            }
                          spids: [2304]
                        )
                      ]
                    )
                    (C {<prepare>} 
                      {(DQ ($ Id.VSub_DollarName '$HS_POOL') <'/'> ($ Id.VSub_DollarName '$src'))} {<Id.Lit_Equals '='>} {<Copy>} 
                      {(DQ ($ Id.VSub_DollarName '$srcdir') <'/'> ($ Id.VSub_DollarName '$src'))}
                    )
                    (C {<prepare>} 
                      {
                        (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                          (braced_var_sub
                            token: <Id.VSub_Name src>
                            suffix_op: 
                              (suffix_op.Unary
                                tok: <Id.VOp1_Percent '%'>
                                arg_word: {<.> <Id.Lit_Other '*'>}
                              )
                          ) <.pkg-name>
                        )
                      } {<Id.Lit_Equals '='>} {<Echo>} {<-> (DQ ($ Id.VSub_Number '$1'))}
                    )
                    (C {<prepare>} 
                      {
                        (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                          (braced_var_sub
                            token: <Id.VSub_Name src>
                            suffix_op: 
                              (suffix_op.Unary
                                tok: <Id.VOp1_Percent '%'>
                                arg_word: {<.> <Id.Lit_Other '*'>}
                              )
                          ) <.options.file>
                        )
                      } {<Id.Lit_Equals '='>} {<Echo>} 
                      {<-> 
                        (DQ <'/'> (${ Id.VSub_Name SETUP_PREFIX) ($ Id.VSub_DollarName '$etcdir') 
                          <'/options'>
                        )
                      }
                    )
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: Cabal.h-sources
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'IFS='> (DQ ($ Id.VSub_DollarName '$IFS') <','>)})
            (C {<local>} {<-a>} 
              {<Id.Lit_VarLike 'extra='> 
                (sh_array_literal
                  left: <Id.Op_LParen _>
                  words: [
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C {<sed>} {<-n>} 
                            {
                              (SQ 
                                <
'/^extra-source-files:/I,/^\\S/{s/^extra-source-files:/ /I;/^\\S/d;p}'
                                >
                              )
                            } {(DQ ($ Id.VSub_Number '$2'))}
                          )
                      )
                    }
                  ]
                )
              }
            )
            (C {<local>} {<-a>} 
              {<Id.Lit_VarLike 'idirs='> 
                (sh_array_literal
                  left: <Id.Op_LParen _>
                  words: [
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Simple
                            redirects: [
                              (redir
                                op: <Id.Redir_Less '<'>
                                loc: (redir_loc.Fd fd:0)
                                arg: {(DQ ($ Id.VSub_Number '$3'))}
                              )
                            ]
                            do_fork: F
                          )
                      )
                    }
                  ]
                )
              }
            )
            (C {<local>} {<file>} {<dir>})
            (C {<mkpdir>} {(DQ ($ Id.VSub_Number '$1'))})
            (command.ForEach
              iter_name: file
              iter_words: [
                {
                  (DQ 
                    (braced_var_sub
                      token: <Id.VSub_Name extra>
                      bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                    )
                  )
                }
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.ForEach
                      iter_name: dir
                      iter_words: [
                        {
                          (DQ 
                            (braced_var_sub
                              token: <Id.VSub_Name idirs>
                              bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                            )
                          )
                        }
                      ]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_GlobDEqual
                                                  left: {(DQ ($ Id.VSub_DollarName '$file'))}
                                                  right: 
                                                    {(DQ ($ Id.VSub_DollarName '$dir')) <'/'> 
                                                      <Id.Lit_Other '*'> <.h>
                                                    }
                                                )
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (C {<printf>} {(DQ <'%s'> <Id.Lit_BadBackslash '\\'> <n>)} 
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            token: <Id.VSub_Name file>
                                            suffix_op: 
                                              (suffix_op.Unary
                                                tok: <Id.VOp1_Pound '#'>
                                                arg_word: 
                                                  {($ Id.VSub_DollarName '$dir') <Id.Lit_Slash '/'>}
                                              )
                                          )
                                        )
                                      }
                                    )
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Break break>
                                    )
                                  ]
                                  spids: [2503 2523]
                                )
                              ]
                            )
                          ]
                        )
                    )
                  ]
                )
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_Number '$1'))}
                )
              ]
            )
          ]
        )
    )
    (C {<Setup.hook>} {<HS.auto_files>})
    (command.ShFunction
      name: HS.auto_files
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_EqualTilde
                      left: {(DQ ($ Id.VSub_Number '$1'))}
                      right: 
                        {<Id.Lit_Other '^'> <Id.Lit_Other '('> (DQ ($ Id.VSub_DollarName '$HS_PKG')) 
                          <Id.Lit_Other '|'> (DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Other '|'> (DQ ($ Id.VSub_DollarName '$HS_CONF')) 
                          <Id.Lit_Other '|'> (DQ ($ Id.VSub_DollarName '$HS_POOL')) <Id.Lit_Other '|'> (DQ ($ Id.VSub_DollarName '$HS_OBJ')) 
                          <Id.Lit_Other '|'> (DQ ($ Id.VSub_DollarName '$HS_BIN')) <Id.Lit_Other ')'> <'/'> <Id.Lit_Other '('> <Id.Lit_Other .> 
                          <Id.Lit_Other '*'> <Id.Lit_Other ')'>
                        }
                    )
                )
                (BraceGroup
                  children: [
                    (C {<local>} 
                      {<Id.Lit_VarLike 'root='> 
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name BASH_REMATCH>
                            bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 1>})
                          )
                        )
                      } 
                      {<Id.Lit_VarLike 'path='> 
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name BASH_REMATCH>
                            bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 2>})
                          )
                        )
                      }
                    )
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName '$root'))}
                      arms: [
                        (case_arm
                          pat_list: [{(DQ ($ Id.VSub_DollarName '$HS_CONF'))}]
                          action: [
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_DollarName '$path'))}
                              arms: [
                                (case_arm
                                  pat_list: [{<manifest.files>}]
                                  action: [
                                    (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} {<Id.Lit_Equals '='>} 
                                      {<Foreach>} {<-> (SQ <'$HS_PKG/$word/conf.manifest'>)} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: (C {<Config.param>} {<'/haskell/packages'>})
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  spids: [2671 2672 2696 -1]
                                )
                                (case_arm
                                  pat_list: [{<manifest>}]
                                  action: [
                                    (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} {<Id.Lit_Equals '='>} 
                                      {<Sorted>} {<Id.Lit_At '@'> (DQ ($ Id.VSub_DollarName '$HS_CONF') <'/manifest.files'>)}
                                    )
                                  ]
                                  spids: [2699 2700 2717 -1]
                                )
                                (case_arm
                                  pat_list: [{<c-manifest.files>}]
                                  action: [
                                    (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} {<Id.Lit_Equals '='>} 
                                      {<Foreach>} {<-> (SQ <'$HS_PKG/$word/conf.c-manifest'>)} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: (C {<Config.param>} {<'/haskell/packages'>})
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  spids: [2720 2721 2745 -1]
                                )
                                (case_arm
                                  pat_list: [{<c-manifest>}]
                                  action: [
                                    (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} {<Id.Lit_Equals '='>} 
                                      {<Sorted>} {<Id.Lit_At '@'> (DQ ($ Id.VSub_DollarName '$HS_CONF') <'/c-manifest.files'>)}
                                    )
                                  ]
                                  spids: [2748 2749 2766 -1]
                                )
                                (case_arm
                                  pat_list: [{<base-packages.full>}]
                                  action: [
                                    (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} {<Id.Lit_Equals '='>} 
                                      {<HS.fullPkgs>} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: (C {<Config.param>} {<'/haskell/base-packages'>})
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  spids: [2769 2770 2789 -1]
                                )
                                (case_arm
                                  pat_list: [{<base-modules>}]
                                  action: [
                                    (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} {<Id.Lit_Equals '='>} 
                                      {<HS.pkgMods>} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: (C {<Config.param>} {<'/haskell/base-packages'>})
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  spids: [2792 2793 2812 -1]
                                )
                                (case_arm
                                  pat_list: [{<macros.h>}]
                                  action: [
                                    (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} {<Id.Lit_Equals '='>} 
                                      {<HS.macros>} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: (C {<Config.param>} {<'/haskell/packages'>})
                                          )
                                        )
                                      } 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: (C {<Config.param>} {<'/haskell/local-packages'>})
                                          )
                                        )
                                      } {(DQ ($ Id.VSub_DollarName '$HS_CONF') <'/base-packages.full'>)}
                                    )
                                  ]
                                  spids: [2815 2816 2848 -1]
                                )
                              ]
                            )
                          ]
                          spids: [2656 2659 2852 -1]
                        )
                        (case_arm
                          pat_list: [{(DQ ($ Id.VSub_DollarName '$HS_PKG'))}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {<-e>} 
                                              {
                                                (DQ ($ Id.VSub_DollarName '$SETUP_ROOT') 
                                                  ($ Id.VSub_DollarName '$HS_SRC') <'/'> ($ Id.VSub_DollarName '$path')
                                                )
                                              } {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} {<Id.Lit_Equals '='>} 
                                      {<Copy>} {(DQ ($ Id.VSub_DollarName '$HS_SRC') <'/'> ($ Id.VSub_DollarName '$path'))}
                                    )
                                  ]
                                  spids: [2861 2877]
                                )
                              ]
                              else_action: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_EqualTilde
                                          left: {(DQ ($ Id.VSub_DollarName '$path'))}
                                          right: 
                                            {<Id.Lit_Other '^'> <Id.Lit_Other '('> <Id.Lit_Other '['> 
                                              <Id.Lit_Other '^'> <'/'> <Id.Lit_Other ']'> <Id.Lit_Other '*'> <Id.Lit_Other ')'> <'/'> <Id.Lit_Other '('> <package> 
                                              <Id.Lit_RegexMeta '\\.'> <Id.Lit_Other '('> <tar> <Id.Lit_RegexMeta '\\.'> <gz> <Id.Lit_Other '|'> <cabal> <Id.Lit_Other '('> 
                                              <Id.Lit_RegexMeta '\\.'> <ar-path> <Id.Lit_Other ')'> <Id.Lit_Other '?'> <Id.Lit_Other ')'> <Id.Lit_Other '|'> <modules> 
                                              <Id.Lit_Other '|'> <conf> <Id.Lit_Other .> <Id.Lit_Other '('> <c-> <Id.Lit_Other ')'> <Id.Lit_Other '?'> <manifest> 
                                              <Id.Lit_Other '|'> <Id.Lit_Other '('> <all-> <Id.Lit_Other '|'> <other-> <Id.Lit_Other '|'> <Id.Lit_Other ')'> <extensions> 
                                              <Id.Lit_Other '|'> <Id.Lit_Other '('> <ext-> <Id.Lit_Other '|'> <ghc-> <Id.Lit_Other '|'> <Id.Lit_Other ')'> <options> 
                                              <Id.Lit_Other '|'> <Id.Lit_Other '['> <ch> <Id.Lit_Other ']'> <-sources> <Id.Lit_Other '|'> <includes> <Id.Lit_Other '|'> 
                                              <include-dirs> <Id.Lit_Other ')'> <Id.Lit_Other '$'>
                                            }
                                        )
                                    )
                                    (BraceGroup
                                      children: [
                                        (C {<local>} 
                                          {<Id.Lit_VarLike 'pkg='> 
                                            (DQ 
                                              (braced_var_sub
                                                token: <Id.VSub_Name BASH_REMATCH>
                                                bracket_op: 
                                                  (bracket_op.ArrayIndex
                                                    expr: {<Id.Lit_Digits 1>}
                                                  )
                                              )
                                            )
                                          } 
                                          {<Id.Lit_VarLike 'file='> 
                                            (DQ 
                                              (braced_var_sub
                                                token: <Id.VSub_Name BASH_REMATCH>
                                                bracket_op: 
                                                  (bracket_op.ArrayIndex
                                                    expr: {<Id.Lit_Digits 2>}
                                                  )
                                              )
                                            )
                                          }
                                        )
                                        (command.Case
                                          to_match: {(DQ ($ Id.VSub_DollarName '$file'))}
                                          arms: [
                                            (case_arm
                                              pat_list: [{<package.tar.gz>}]
                                              action: [
                                                (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                  {<Id.Lit_Equals '='>} {<Hackage.get>} {<-> (DQ ($ Id.VSub_DollarName '$pkg'))}
                                                )
                                              ]
                                              spids: [3009 3010 3026 -1]
                                            )
                                            (case_arm
                                              pat_list: [{<package.cabal.ar-path>}]
                                              action: [
                                                (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                  {<Id.Lit_Equals '='>} {<Tar.find>} 
                                                  {<-> 
                                                    (DQ 
                                                      (braced_var_sub
                                                        token: <Id.VSub_Name pkg>
                                                        suffix_op: 
                                                          (suffix_op.Unary
                                                            tok: <Id.VOp1_Percent '%'>
                                                            arg_word: {<-> <Id.Lit_Other '*'>}
                                                          )
                                                      )
                                                    ) (SQ <'\\.cabal$'>)
                                                  } {(DQ ($ Id.VSub_DollarName '$HS_PKG') <'/'> ($ Id.VSub_DollarName '$pkg') <'/package.tar.gz'>)}
                                                )
                                              ]
                                              spids: [3029 3030 3061 -1]
                                            )
                                            (case_arm
                                              pat_list: [{<package.cabal>}]
                                              action: [
                                                (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                  {<Id.Lit_Equals '='>} {<Tar.get>} 
                                                  {
                                                    (DQ ($ Id.VSub_DollarName '$HS_PKG') <'/'> 
                                                      ($ Id.VSub_DollarName '$pkg') <'/package.tar.gz'>
                                                    )
                                                  } {(DQ ($ Id.VSub_DollarName '$HS_PKG') <'/'> ($ Id.VSub_DollarName '$pkg') <'/package.cabal.ar-path'>)}
                                                )
                                              ]
                                              spids: [3064 3065 3090 -1]
                                            )
                                            (case_arm
                                              pat_list: [{<modules>}]
                                              action: [
                                                (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                  {<Id.Lit_Equals '='>} {<Cabal.section>} {<-> (SQ <'(exposed|other)'>) <-modules>} 
                                                  {
                                                    (DQ ($ Id.VSub_DollarName '$HS_PKG') <'/'> 
                                                      ($ Id.VSub_DollarName '$pkg') <'/package.cabal'>
                                                    )
                                                  } {<-> (SQ <','>)}
                                                )
                                              ]
                                              spids: [3093 3094 3123 -1]
                                            )
                                            (case_arm
                                              pat_list: [{<extensions>}]
                                              action: [
                                                (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                  {<Id.Lit_Equals '='>} {<Cabal.section>} {<-> (SQ <'(default-)?'>) <extensions>} 
                                                  {
                                                    (DQ ($ Id.VSub_DollarName '$HS_PKG') <'/'> 
                                                      ($ Id.VSub_DollarName '$pkg') <'/package.cabal'>
                                                    )
                                                  } {<-> <Id.Lit_Comma ','>}
                                                )
                                              ]
                                              spids: [3126 3127 3154 -1]
                                            )
                                            (case_arm
                                              pat_list: [{<other-extensions>}]
                                              action: [
                                                (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                  {<Id.Lit_Equals '='>} {<Cabal.section>} {<-other-extensions>} 
                                                  {
                                                    (DQ ($ Id.VSub_DollarName '$HS_PKG') <'/'> 
                                                      ($ Id.VSub_DollarName '$pkg') <'/package.cabal'>
                                                    )
                                                  } {<-> <Id.Lit_Comma ','>}
                                                )
                                              ]
                                              spids: [3157 3158 3181 -1]
                                            )
                                            (case_arm
                                              pat_list: [{<c-sources>}]
                                              action: [
                                                (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                  {<Id.Lit_Equals '='>} {<Cabal.section>} {<-c-sources>} 
                                                  {
                                                    (DQ ($ Id.VSub_DollarName '$HS_PKG') <'/'> 
                                                      ($ Id.VSub_DollarName '$pkg') <'/package.cabal'>
                                                    )
                                                  } {<-> <Id.Lit_Comma ','>}
                                                )
                                              ]
                                              spids: [3184 3185 3208 -1]
                                            )
                                            (case_arm
                                              pat_list: [{<h-sources>}]
                                              action: [
                                                (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                  {<Id.Lit_Equals '='>} {<Cabal.h-sources>} 
                                                  (word.BracedTree
                                                    parts: [
                                                      (DQ ($ Id.VSub_DollarName '$HS_PKG') <'/'> 
                                                        ($ Id.VSub_DollarName '$pkg') <'/'>
                                                      )
                                                      (word_part.BracedTuple
                                                        words: [{<package.cabal>} {<include-dirs>}]
                                                      )
                                                    ]
                                                  )
                                                )
                                              ]
                                              spids: [3211 3212 3235 -1]
                                            )
                                            (case_arm
                                              pat_list: [{<includes>}]
                                              action: [
                                                (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                  {<Id.Lit_Equals '='>} {<Cabal.section>} {<-> (SQ <'(includes|install-includes)'>)} 
                                                  {
                                                    (DQ ($ Id.VSub_DollarName '$HS_PKG') <'/'> 
                                                      ($ Id.VSub_DollarName '$pkg') <'/package.cabal'>
                                                    )
                                                  } {<-> <Id.Lit_Comma ','>}
                                                )
                                              ]
                                              spids: [3238 3239 3265 -1]
                                            )
                                            (case_arm
                                              pat_list: [{<include-dirs>}]
                                              action: [
                                                (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                  {<Id.Lit_Equals '='>} {<Cabal.section>} {<-include-dirs>} 
                                                  {
                                                    (DQ ($ Id.VSub_DollarName '$HS_PKG') <'/'> 
                                                      ($ Id.VSub_DollarName '$pkg') <'/package.cabal'>
                                                    )
                                                  } {<-> <Id.Lit_Comma ','>}
                                                )
                                              ]
                                              spids: [3268 3269 3292 -1]
                                            )
                                            (case_arm
                                              pat_list: [{<all-extensions>}]
                                              action: [
                                                (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                  {<Id.Lit_Equals '='>} {<Concat>} 
                                                  (word.BracedTree
                                                    parts: [
                                                      (DQ ($ Id.VSub_DollarName '$HS_PKG') <'/'> 
                                                        ($ Id.VSub_DollarName '$pkg') <'/'>
                                                      )
                                                      (word_part.BracedTuple
                                                        words: [{<other->} {}]
                                                      )
                                                      <extensions>
                                                    ]
                                                  )
                                                )
                                              ]
                                              spids: [3295 3296 3319 -1]
                                            )
                                            (case_arm
                                              pat_list: [{<ghc-options>}]
                                              action: [
                                                (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                  {<Id.Lit_Equals '='>} {<Cabal.section>} {<-ghc-options>} 
                                                  {
                                                    (DQ ($ Id.VSub_DollarName '$HS_PKG') <'/'> 
                                                      ($ Id.VSub_DollarName '$pkg') <'/package.cabal'>
                                                    )
                                                  }
                                                )
                                              ]
                                              spids: [3322 3323 3343 -1]
                                            )
                                            (case_arm
                                              pat_list: [{<ext-options>}]
                                              action: [
                                                (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                  {<Id.Lit_Equals '='>} {<Foreach>} {<-> (SQ <'-X$word'>)} 
                                                  {
                                                    (DQ ($ Id.VSub_DollarName '$HS_PKG') <'/'> 
                                                      ($ Id.VSub_DollarName '$pkg') <'/extensions'>
                                                    )
                                                  }
                                                )
                                              ]
                                              spids: [3346 3347 3370 -1]
                                            )
                                            (case_arm
                                              pat_list: [{<options>}]
                                              action: [
                                                (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                  {<Id.Lit_Equals '='>} {<Concat>} 
                                                  (word.BracedTree
                                                    parts: [
                                                      (DQ ($ Id.VSub_DollarName '$HS_PKG') <'/'> 
                                                        ($ Id.VSub_DollarName '$pkg') <'/'>
                                                      )
                                                      (word_part.BracedTuple
                                                        words: [{<ext>} {<ghc>}]
                                                      )
                                                      <-options>
                                                    ]
                                                  )
                                                )
                                              ]
                                              spids: [3373 3374 3398 -1]
                                            )
                                            (case_arm
                                              pat_list: [{<conf.manifest>}]
                                              action: [
                                                (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                  {<Id.Lit_Equals '='>} {<Foreach>} {<-> (SQ <'$word:'>) (DQ ($ Id.VSub_DollarName '$pkg'))} 
                                                  {
                                                    (DQ ($ Id.VSub_DollarName '$HS_PKG') <'/'> 
                                                      ($ Id.VSub_DollarName '$pkg') <'/modules'>
                                                    )
                                                  }
                                                )
                                              ]
                                              spids: [3401 3402 3428 -1]
                                            )
                                            (case_arm
                                              pat_list: [{<conf.c-manifest>}]
                                              action: [
                                                (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                  {<Id.Lit_Equals '='>} {<Foreach>} {<-> (SQ <'$word:'>) (DQ ($ Id.VSub_DollarName '$pkg'))} 
                                                  {
                                                    (DQ ($ Id.VSub_DollarName '$HS_PKG') <'/'> 
                                                      ($ Id.VSub_DollarName '$pkg') <'/c-sources'>
                                                    )
                                                  } {(DQ ($ Id.VSub_DollarName '$HS_PKG') <'/'> ($ Id.VSub_DollarName '$pkg') <'/h-sources'>)} 
                                                  {
                                                    (DQ ($ Id.VSub_DollarName '$HS_PKG') <'/'> 
                                                      ($ Id.VSub_DollarName '$pkg') <'/includes'>
                                                    )
                                                  }
                                                )
                                              ]
                                              spids: [3431 3432 3472 -1]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                          spids: [2855 2858 3482 -1]
                        )
                        (case_arm
                          pat_list: [
                            {(DQ ($ Id.VSub_DollarName '$HS_DEP'))}
                            {(DQ ($ Id.VSub_DollarName '$HS_POOL'))}
                            {(DQ ($ Id.VSub_DollarName '$HS_OBJ'))}
                          ]
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_EqualTilde
                                      left: {(DQ ($ Id.VSub_DollarName '$path'))}
                                      right: 
                                        {<Id.Lit_Other '^'> <Id.Lit_Other '('> <Id.Lit_Other .> 
                                          <Id.Lit_Other '*'> <Id.Lit_Other ')'> <Id.Lit_RegexMeta '\\.'> <Id.Lit_Other '('> <Id.Lit_Other '('> <c-> <Id.Lit_Other ')'> 
                                          <Id.Lit_Other '?'> <pkg-name> <Id.Lit_Other '|'> <Id.Lit_Other '('> <c-> <Id.Lit_Other ')'> <Id.Lit_Other '?'> <pkg> 
                                          <Id.Lit_RegexMeta '\\.'> <file> <Id.Lit_Other '|'> <hs> <Id.Lit_Other '('> <c> <Id.Lit_Other '?'> <Id.Lit_RegexMeta '\\.'> <ar-path> 
                                          <Id.Lit_Other '|'> <Id.Lit_RegexMeta '\\.'> <args> <Id.Lit_Other '|'> <pp> <Id.Lit_Other '('> <Id.Lit_RegexMeta '\\.'> <files> 
                                          <Id.Lit_Other ')'> <Id.Lit_Other '?'> <Id.Lit_Other '|'> <Id.Lit_Other '('> <c> <Id.Lit_Other '('> <_hs> <Id.Lit_Other ')'> 
                                          <Id.Lit_Other '?'> <Id.Lit_Other ')'> <Id.Lit_Other '?'> <Id.Lit_Other ')'> <Id.Lit_Other '|'> <depends> <Id.Lit_Other '|'> 
                                          <Id.Lit_Other '('> <c-> <Id.Lit_Other ')'> <Id.Lit_Other '?'> <o> <Id.Lit_Other '('> <Id.Lit_RegexMeta '\\.'> 
                                          <Id.Lit_Other '('> <c-> <Id.Lit_Other ')'> <Id.Lit_Other '?'> <files> <Id.Lit_Other ')'> <Id.Lit_Other '?'> <Id.Lit_Other '|'> 
                                          <full-o> <Id.Lit_RegexMeta '\\.'> <files> <Id.Lit_Other '|'> <hi> <Id.Lit_Other '|'> <options> 
                                          <Id.Lit_RegexMeta '\\.'> <file> <Id.Lit_Other '|'> <full-deps> <Id.Lit_Other '('> <Id.Lit_RegexMeta '\\.'> <files> 
                                          <Id.Lit_Other ')'> <Id.Lit_Other '?'> <Id.Lit_Other '|'> <pkg-deps> <Id.Lit_Other '('> <Id.Lit_RegexMeta '\\.'> <files> 
                                          <Id.Lit_Other '|'> <Id.Lit_RegexMeta '\\.'> <local> <Id.Lit_Other ')'> <Id.Lit_Other '?'> <Id.Lit_Other '|'> 
                                          <Id.Lit_Other '['> <ch> <Id.Lit_Other ']'> <Id.Lit_Other '('> <-sources> <Id.Lit_Other '('> <Id.Lit_RegexMeta '\\.'> <files> 
                                          <Id.Lit_Other ')'> <Id.Lit_Other '?'> <Id.Lit_Other '|'> <Id.Lit_RegexMeta '\\.'> <ar-path> <Id.Lit_Other '|'> 
                                          <Id.Lit_Other ')'> <Id.Lit_Other '|'> <incs> <Id.Lit_Other '|'> <full-incs> <Id.Lit_Other '('> <Id.Lit_RegexMeta '\\.'> 
                                          <files> <Id.Lit_Other ')'> <Id.Lit_Other '?'> <Id.Lit_Other '|'> <bin-> <Id.Lit_Other '('> <hs> <Id.Lit_Other '|'> 
                                          <c> <Id.Lit_Other ')'> <-o> <Id.Lit_RegexMeta '\\.'> <files> <Id.Lit_Other ')'> <Id.Lit_Other '$'>
                                        }
                                    )
                                )
                                (BraceGroup
                                  children: [
                                    (C {<local>} 
                                      {<Id.Lit_VarLike 'mod='> 
                                        (DQ 
                                          (braced_var_sub
                                            token: <Id.VSub_Name BASH_REMATCH>
                                            bracket_op: 
                                              (bracket_op.ArrayIndex
                                                expr: {<Id.Lit_Digits 1>}
                                              )
                                          )
                                        )
                                      } 
                                      {<Id.Lit_VarLike 'ext='> 
                                        (DQ 
                                          (braced_var_sub
                                            token: <Id.VSub_Name BASH_REMATCH>
                                            bracket_op: 
                                              (bracket_op.ArrayIndex
                                                expr: {<Id.Lit_Digits 2>}
                                              )
                                          )
                                        )
                                      }
                                    )
                                    (command.Case
                                      to_match: 
                                        {
                                          (DQ ($ Id.VSub_DollarName '$root') <':'> 
                                            ($ Id.VSub_DollarName '$ext')
                                          )
                                        }
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <pkg-name>
                                            }
                                          ]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: 
                                                    (condition.Shell
                                                      commands: [
                                                        (command.Sentence
                                                          child: 
                                                            (C {<HS.isLocalMod>} 
                                                              {(DQ ($ Id.VSub_DollarName '$mod'))}
                                                            )
                                                          terminator: <Id.Op_Semi _>
                                                        )
                                                      ]
                                                    )
                                                  action: [
                                                    (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                      {<Id.Lit_Equals '='>} {<Echo>} 
                                                      {<-> 
                                                        (DQ 
                                                          (braced_var_sub
                                                            token: <Id.VSub_Name HS_MOD_PATH>
                                                            suffix_op: 
                                                              (suffix_op.PatSub
                                                                pat: 
                                                                  {
                                                                    (word_part.EscapedLiteral
                                                                      token: 
                                                                        <Id.Lit_EscapedChar '\\/'>
                                                                    )
                                                                  }
                                                                replace: {<->}
                                                                replace_mode: Id.Lit_Slash
                                                              )
                                                          )
                                                        )
                                                      }
                                                    )
                                                  ]
                                                  spids: [3685 3694]
                                                )
                                              ]
                                              else_action: [
                                                (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                  {<Id.Lit_Equals '='>} {<Lookup>} 
                                                  {<-> 
                                                    (DQ 
                                                      (braced_var_sub
                                                        token: <Id.VSub_Name mod>
                                                        suffix_op: 
                                                          (suffix_op.PatSub
                                                            pat: 
                                                              {
                                                                (word_part.EscapedLiteral
                                                                  token: <Id.Lit_EscapedChar '\\/'>
                                                                )
                                                              }
                                                            replace: {<.>}
                                                            replace_mode: Id.Lit_Slash
                                                          )
                                                      ) <':'>
                                                    )
                                                  } {(DQ ($ Id.VSub_DollarName '$HS_CONF') <'/manifest'>)}
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [3677 3682 3753 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <c-pkg-name>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<Lookup>} {<-> (DQ ($ Id.VSub_DollarName '$mod'))} 
                                              {(DQ ($ Id.VSub_DollarName '$HS_CONF') <'/c-manifest'>)}
                                            )
                                          ]
                                          spids: [3756 3761 3782 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <pkg.file>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<Foreach>} {<-> (SQ <'$HS_PKG/$word/package.tar.gz'>)} 
                                              {
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.pkg-name>
                                                )
                                              }
                                            )
                                          ]
                                          spids: [3785 3790 3813 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <c-pkg.file>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<Foreach>} {<-> (SQ <'$HS_PKG/$word/package.tar.gz'>)} 
                                              {
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.c-pkg-name>
                                                )
                                              }
                                            )
                                          ]
                                          spids: [3816 3821 3844 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <c.ar-path>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<Tar.find>} 
                                              {<-> (SQ <'\\(^\\|/\\)'>) 
                                                (DQ ($ Id.VSub_DollarName '$mod') 
                                                  (word_part.EscapedLiteral
                                                    token: <Id.Lit_EscapedChar '\\\\'>
                                                  ) <.c> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>)
                                                )
                                              } 
                                              {<Id.Lit_At '@'> 
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.c.c-pkg.file>
                                                )
                                              }
                                            )
                                          ]
                                          spids: [3847 3852 3882 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <h.ar-path>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<Tar.find>} 
                                              {<-> (SQ <'\\(^\\|/\\)'>) 
                                                (DQ ($ Id.VSub_DollarName '$mod') 
                                                  (word_part.EscapedLiteral
                                                    token: <Id.Lit_EscapedChar '\\\\'>
                                                  ) <.h> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>)
                                                )
                                              } 
                                              {<Id.Lit_At '@'> 
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.h.c-pkg.file>
                                                )
                                              }
                                            )
                                          ]
                                          spids: [3885 3890 3920 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_POOL')) 
                                              <Id.Lit_Colon ':'> <c>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<Tar.get>} 
                                              {<Id.Lit_At '@'> 
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.c-pkg.file>
                                                )
                                              } {(DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> ($ Id.VSub_DollarName '$mod') <.c.ar-path>)}
                                            )
                                          ]
                                          spids: [3923 3928 3954 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_POOL')) 
                                              <Id.Lit_Colon ':'> <h>
                                            }
                                          ]
                                          action: [
                                            (command.Case
                                              to_match: {(DQ ($ Id.VSub_DollarName '$mod'))}
                                              arms: [
                                                (case_arm
                                                  pat_list: [
                                                    {<HsBase> <Id.Lit_Star '*'>}
                                                    {<'rts/'> <Id.Lit_Star '*'>}
                                                    {<Rts> <Id.Lit_Star '*'>}
                                                    {<Stg> <Id.Lit_Star '*'>}
                                                    {<HsFFI>}
                                                    {<'stg/'> <Id.Lit_Star '*'>}
                                                    {<ghcconfig>}
                                                    {<ghcplatform>}
                                                    {<MachRegs>}
                                                    {<WCsubst>}
                                                  ]
                                                  action: [
                                                    (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                      {<Id.Lit_Equals '='>} {<HS.StdHeader>} {<-> (DQ ($ Id.VSub_DollarName '$mod'))}
                                                    )
                                                  ]
                                                  spids: [3974 3998 4015 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{<MachDeps>}]
                                                  action: [
                                                    (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                      {<Id.Lit_Equals '='>} {<HS.MachDeps>}
                                                    )
                                                  ]
                                                  spids: [4018 4019 4030 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{<ghcautoconf>}]
                                                  action: [
                                                    (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                      {<Id.Lit_Equals '='>} {<HS.GHCAutoConf>}
                                                    )
                                                  ]
                                                  spids: [4033 4034 4045 -1]
                                                )
                                                (case_arm
                                                  pat_list: [{<Id.Lit_Star '*'>}]
                                                  action: [
                                                    (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                      {<Id.Lit_Equals '='>} {<Tar.get>} 
                                                      {<Id.Lit_At '@'> 
                                                        (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                          ($ Id.VSub_DollarName '$mod') <.c-pkg.file>
                                                        )
                                                      } {(DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> ($ Id.VSub_DollarName '$mod') <.h.ar-path>)}
                                                    )
                                                  ]
                                                  spids: [4048 4049 -1 4077]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [3957 3962 4078 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <hs.ar-path>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<Tar.find>} 
                                              {<-> 
                                                (DQ ($ Id.VSub_DollarName '$mod') 
                                                  (word_part.EscapedLiteral
                                                    token: <Id.Lit_EscapedChar '\\\\'>
                                                  ) <.hsc> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\\'>) <'?'> 
                                                  (word_part.EscapedLiteral
                                                    token: <Id.Lit_EscapedChar '\\$'>
                                                  )
                                                )
                                              } {<Id.Lit_At '@'> (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> ($ Id.VSub_DollarName '$mod') <.pkg.file>)}
                                            )
                                          ]
                                          spids: [4082 4087 4116 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <hs.args>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<HS.get.args>} {<-> (DQ ($ Id.VSub_DollarName '$mod'))} 
                                              (word.BracedTree
                                                parts: [
                                                  (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                    ($ Id.VSub_DollarName '$mod') <.>
                                                  )
                                                  (word_part.BracedTuple
                                                    words: [{<pkg.file>} {<hs.ar-path>}]
                                                  )
                                                ]
                                              )
                                            )
                                          ]
                                          spids: [4119 4124 4152 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <hsc_hs>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<HS.hsc>} {(DQ ($ Id.VSub_DollarName '$HS_POOL') <'/'> ($ Id.VSub_DollarName '$mod') <.hsc>)} 
                                              {(DQ ($ Id.VSub_DollarName '$HS_CONF') <'/macros.h'>)} 
                                              {<Id.Lit_At '@'> 
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.hsc.full-incs>
                                                ) (SQ <'{"$HS_POOL/$word"}'>)
                                              }
                                            )
                                          ]
                                          spids: [4155 4160 4194 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_POOL')) 
                                              <Id.Lit_Colon ':'> <hs>
                                            }
                                          ]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: 
                                                    (condition.Shell
                                                      commands: [
                                                        (command.Sentence
                                                          child: 
                                                            (C {<HS.isLocalMod>} 
                                                              {(DQ ($ Id.VSub_DollarName '$mod'))}
                                                            )
                                                          terminator: <Id.Op_Semi _>
                                                        )
                                                      ]
                                                    )
                                                  action: [
                                                    (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                      {<Id.Lit_Equals '='>} {<Copy>} 
                                                      {
                                                        (DQ ($ Id.VSub_DollarName '$HS_SRC') <'/'> 
                                                          ($ Id.VSub_DollarName '$HS_MOD_PATH') <'/source/'> ($ Id.VSub_DollarName '$mod') <.hs>
                                                        )
                                                      }
                                                    )
                                                  ]
                                                  spids: [4205 4214]
                                                )
                                              ]
                                              else_action: [
                                                (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                  {<Id.Lit_Equals '='>} {<Choose>} 
                                                  {<Id.Lit_At '@'> 
                                                    (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                      ($ Id.VSub_DollarName '$mod') <.hs.args>
                                                    )
                                                  }
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [4197 4202 4260 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_POOL')) 
                                              <Id.Lit_Colon ':'> <hsc>
                                            }
                                          ]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: 
                                                    (condition.Shell
                                                      commands: [
                                                        (command.Sentence
                                                          child: 
                                                            (C {<HS.isLocalMod>} 
                                                              {(DQ ($ Id.VSub_DollarName '$mod'))} {<hsc>}
                                                            )
                                                          terminator: <Id.Op_Semi _>
                                                        )
                                                      ]
                                                    )
                                                  action: [
                                                    (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                      {<Id.Lit_Equals '='>} {<Copy>} 
                                                      {
                                                        (DQ ($ Id.VSub_DollarName '$HS_SRC') <'/'> 
                                                          ($ Id.VSub_DollarName '$HS_MOD_PATH') <'/source/'> ($ Id.VSub_DollarName '$mod') <.hsc>
                                                        )
                                                      }
                                                    )
                                                  ]
                                                  spids: [4272 4283]
                                                )
                                              ]
                                              else_action: [
                                                (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                  {<Id.Lit_Equals '='>} {<Tar.get>} 
                                                  {<Id.Lit_At '@'> 
                                                    (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                      ($ Id.VSub_DollarName '$mod') <.pkg.file>
                                                    )
                                                  } {(DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> ($ Id.VSub_DollarName '$mod') <.hs.ar-path>)}
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [4264 4269 4336 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <hspp.files>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<Foreach>} {<-> (SQ <'$HS_POOL/$word'>)} 
                                              {
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.hs.full-incs>
                                                )
                                              }
                                            )
                                          ]
                                          spids: [4339 4344 4367 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_POOL')) 
                                              <Id.Lit_Colon ':'> <hspp>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<HS.pp>} {(DQ ($ Id.VSub_DollarName '$HS_POOL') <'/'> ($ Id.VSub_DollarName '$mod') <.hs>)} 
                                              {(DQ ($ Id.VSub_DollarName '$HS_CONF') <'/macros.h'>)} 
                                              {<Id.Lit_At '@'> 
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.hspp.files>
                                                )
                                              }
                                            )
                                          ]
                                          spids: [4370 4375 4406 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <depends>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<HS.depends>} {(DQ ($ Id.VSub_DollarName '$HS_POOL') <'/'> ($ Id.VSub_DollarName '$mod') <.hspp>)} 
                                              {
                                                (DQ ($ Id.VSub_DollarName '$HS_CONF') 
                                                  <'/base-modules'>
                                                )
                                              }
                                            )
                                          ]
                                          spids: [4409 4414 4437 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <pkg-deps.files>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<Foreach>} {<-> (SQ <'$HS_DEP/${word//.//}.pkg-deps'>)} 
                                              {
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.depends>
                                                )
                                              }
                                            )
                                          ]
                                          spids: [4440 4445 4468 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <pkg-deps>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<Sorted>} {(DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> ($ Id.VSub_DollarName '$mod') <.pkg-name>)} 
                                              {<Id.Lit_At '@'> 
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.pkg-deps.files>
                                                )
                                              }
                                            )
                                          ]
                                          spids: [4471 4476 4502 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <pkg-deps.local>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<Filter>} {(DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> ($ Id.VSub_DollarName '$mod') <.pkg-deps>)} 
                                              {
                                                (DQ 
                                                  (command_sub
                                                    left_token: <Id.Left_DollarParen '$('>
                                                    child: 
                                                      (C {<Config.param>} {<'/haskell/local-packages'>})
                                                  )
                                                )
                                              } {<-v>}
                                            )
                                          ]
                                          spids: [4505 4510 4538 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <full-deps.files>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<Foreach>} {<-> (SQ <'$HS_DEP/${word//.//}.full-deps'>)} 
                                              {
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.depends>
                                                )
                                              }
                                            )
                                          ]
                                          spids: [4541 4546 4569 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <full-deps>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<Sorted>} {(DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> ($ Id.VSub_DollarName '$mod') <.depends>)} 
                                              {<Id.Lit_At '@'> 
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.full-deps.files>
                                                )
                                              }
                                            )
                                          ]
                                          spids: [4572 4577 4603 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <incs>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<HS.includes>} {(DQ ($ Id.VSub_DollarName '$HS_POOL') <'/'> ($ Id.VSub_DollarName '$mod'))}
                                            )
                                          ]
                                          spids: [4606 4611 4628 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <full-incs.files>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<Foreach>} {<-> (SQ <'$HS_DEP/$word.full-incs'>)} 
                                              {
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.incs>
                                                )
                                              }
                                            )
                                          ]
                                          spids: [4631 4636 4659 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <full-incs>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<Sorted>} {(DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> ($ Id.VSub_DollarName '$mod') <.incs>)} 
                                              {<Id.Lit_At '@'> 
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.full-incs.files>
                                                )
                                              }
                                            )
                                          ]
                                          spids: [4662 4667 4693 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <c-sources.files>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<Foreach>} {<-> (SQ <'$HS_PKG/$word/c-sources'>)} 
                                              {
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.pkg-deps.local>
                                                )
                                              }
                                            )
                                          ]
                                          spids: [4696 4701 4724 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <c-sources>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<Sorted>} 
                                              {<Id.Lit_At '@'> 
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.c-sources.files>
                                                )
                                              }
                                            )
                                          ]
                                          spids: [4727 4732 4751 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <o.c-files>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<Foreach>} {<-> (SQ <'$HS_OBJ/${word#$HS_POOL/}-o'>)} 
                                              {
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.c-sources>
                                                )
                                              }
                                            )
                                          ]
                                          spids: [4754 4759 4782 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <o.files>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<Foreach>} {<-> (SQ <'$HS_OBJ/${word//.//}.o'>)} 
                                              {
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.depends>
                                                )
                                              }
                                            )
                                          ]
                                          spids: [4785 4790 4813 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <options.file>
                                            }
                                          ]
                                          action: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: 
                                                    (condition.Shell
                                                      commands: [
                                                        (command.Sentence
                                                          child: 
                                                            (C {<HS.isLocalMod>} 
                                                              {(DQ ($ Id.VSub_DollarName '$mod'))}
                                                            )
                                                          terminator: <Id.Op_Semi _>
                                                        )
                                                      ]
                                                    )
                                                  action: [
                                                    (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                      {<Id.Lit_Equals '='>} {<Echo>} 
                                                      {<-> 
                                                        (DQ ($ Id.VSub_DollarName '$HS_SRC') <'/'> 
                                                          ($ Id.VSub_DollarName '$HS_MOD_PATH') <'/options'>
                                                        )
                                                      }
                                                    )
                                                  ]
                                                  spids: [4825 4834]
                                                )
                                              ]
                                              else_action: [
                                                (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                                  {<Id.Lit_Equals '='>} {<Foreach>} {<-> (SQ <'$HS_PKG/$word/options'>)} 
                                                  {
                                                    (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                      ($ Id.VSub_DollarName '$mod') <.pkg-name>
                                                    )
                                                  }
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [4817 4822 4883 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <c-o.files>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<Foreach>} {<-> (SQ <'$HS_POOL/$word'>)} 
                                              {
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.c.full-incs>
                                                )
                                              }
                                            )
                                          ]
                                          spids: [4886 4891 4914 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_OBJ')) <Id.Lit_Colon ':'> 
                                              <c-o>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<HS.cc>} {(DQ ($ Id.VSub_DollarName '$HS_POOL') <'/'> ($ Id.VSub_DollarName '$mod') <.c>)} 
                                              {<Id.Lit_At '@'> 
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.c-o.files>
                                                )
                                              }
                                            )
                                          ]
                                          spids: [4917 4922 4948 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_OBJ')) <Id.Lit_Colon ':'> 
                                              <o>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {
                                                (DQ 
                                                  (braced_var_sub
                                                    token: <Id.VSub_Number 1>
                                                    suffix_op: 
                                                      (suffix_op.PatSub
                                                        pat: {<.o>}
                                                        replace: {<.hi>}
                                                        replace_mode: Id.Undefined_Tok
                                                      )
                                                  )
                                                )
                                              } {<Id.Lit_Equals '='>} {<HS.compile>} 
                                              {
                                                (DQ ($ Id.VSub_DollarName '$HS_POOL') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.hs>
                                                )
                                              } {(DQ ($ Id.VSub_DollarName '$HS_CONF') <'/macros.h'>)} 
                                              {<Id.Lit_At '@'> 
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.options.file>
                                                )
                                              } {<Id.Lit_At '@'> (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> ($ Id.VSub_DollarName '$mod') <.o.files>)} 
                                              {<Id.Lit_At '@'> 
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.o.c-files>
                                                )
                                              }
                                            )
                                          ]
                                          spids: [4951 4956 5013 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <bin-hs-o.files>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<Foreach>} {<-> (SQ <'$HS_OBJ/${word//.//}.o'>)} 
                                              {
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.full-deps>
                                                )
                                              }
                                            )
                                          ]
                                          spids: [5017 5022 5045 -1]
                                        )
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$HS_DEP')) <Id.Lit_Colon ':'> 
                                              <bin-c-o.files>
                                            }
                                          ]
                                          action: [
                                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {<Foreach>} {<-> (SQ <'$(word="${word#$HS_POOL/}"; echo "$HS_OBJ/$word-o")'>)} 
                                              {
                                                (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                                  ($ Id.VSub_DollarName '$mod') <.c-sources>
                                                )
                                              }
                                            )
                                          ]
                                          spids: [5048 5053 5076 -1]
                                        )
                                        (case_arm
                                          pat_list: [{<Id.Lit_Star '*'>}]
                                          action: [
                                            (command.ControlFlow
                                              token: <Id.ControlFlow_Return return>
                                              arg_word: {<1>}
                                            )
                                          ]
                                          spids: [5079 5080 5085 -1]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                          spids: [3485 3496 5092 -1]
                        )
                        (case_arm
                          pat_list: [{(DQ ($ Id.VSub_DollarName '$HS_BIN'))}]
                          action: [
                            (C {<prepare>} {(DQ ($ Id.VSub_Number '$1'))} {<Id.Lit_Equals '='>} {<HS.ld>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: (C {<Config.param>} {<'/haskell/base-packages'>})
                                  )
                                )
                              } 
                              {
                                (DQ ($ Id.VSub_DollarName '$HS_OBJ') <'/'> 
                                  (braced_var_sub
                                    token: <Id.VSub_Name path>
                                    suffix_op: 
                                      (suffix_op.PatSub
                                        pat: {<.>}
                                        replace: {<Id.Lit_Slash '/'>}
                                        replace_mode: Id.Lit_Slash
                                      )
                                  ) <.o>
                                )
                              } 
                              (word.BracedTree
                                parts: [
                                  <Id.Lit_At '@'>
                                  (DQ ($ Id.VSub_DollarName '$HS_DEP') <'/'> 
                                    (braced_var_sub
                                      token: <Id.VSub_Name path>
                                      suffix_op: 
                                        (suffix_op.PatSub
                                          pat: {<.>}
                                          replace: {<Id.Lit_Slash '/'>}
                                          replace_mode: Id.Lit_Slash
                                        )
                                    ) <.bin->
                                  )
                                  (word_part.BracedTuple
                                    words: [{<c>} {<hs>}]
                                  )
                                  (DQ <-o.files>)
                                ]
                              )
                            )
                          ]
                          spids: [5095 5098 5154 -1]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
  ]
)